[glibmm] Run clang-format on glib .h files.
- From: Murray Cumming <murrayc src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [glibmm] Run clang-format on glib .h files.
- Date: Sat, 27 Feb 2016 14:42:54 +0000 (UTC)
commit b2157a47efd33144c65cb46902c89dafba7acfcb
Author: Murray Cumming <murrayc murrayc com>
Date: Fri Feb 26 14:14:04 2016 +0100
Run clang-format on glib .h files.
glib/glibmm/arrayhandle.h | 508 +++++++++---------
glib/glibmm/base64.h | 3 -
glib/glibmm/class.h | 28 +-
glib/glibmm/containerhandle_shared.h | 234 ++++-----
glib/glibmm/containers.h | 204 ++++----
glib/glibmm/debug.h | 65 ++--
glib/glibmm/dispatcher.h | 2 +-
glib/glibmm/error.h | 6 +-
glib/glibmm/exception.h | 3 -
glib/glibmm/exceptionhandler.h | 4 +-
glib/glibmm/helperlist.h | 137 ++---
glib/glibmm/i18n-lib.h | 1 -
glib/glibmm/i18n.h | 1 -
glib/glibmm/init.h | 3 -
glib/glibmm/interface.h | 16 +-
glib/glibmm/listhandle.h | 246 +++++-----
glib/glibmm/main.h | 219 +++++----
glib/glibmm/object.h | 167 +++---
glib/glibmm/objectbase.h | 101 ++--
glib/glibmm/pattern.h | 9 +-
glib/glibmm/priorities.h | 3 +-
glib/glibmm/property.h | 73 ++--
glib/glibmm/propertyproxy.h | 71 ++--
glib/glibmm/propertyproxy_base.h | 19 +-
glib/glibmm/quark.h | 47 +-
glib/glibmm/random.h | 11 +-
glib/glibmm/refptr.h | 205 ++++----
glib/glibmm/sarray.h | 6 +-
glib/glibmm/signalproxy.h | 112 +++--
glib/glibmm/signalproxy_connectionnode.h | 5 +-
glib/glibmm/slisthandle.h | 247 +++++-----
glib/glibmm/streamiochannel.h | 3 +-
glib/glibmm/stringutils.h | 10 +-
glib/glibmm/threadpool.h | 16 +-
glib/glibmm/timer.h | 10 +-
glib/glibmm/timeval.h | 123 +++---
glib/glibmm/ustring.h | 824 +++++++++++++++---------------
glib/glibmm/utility.h | 69 ++--
glib/glibmm/value.h | 44 +-
glib/glibmm/value_custom.h | 123 +++---
glib/glibmm/vectorutils.h | 411 ++++++++-------
glib/glibmm/weakref.h | 106 +++--
glib/glibmm/wrap.h | 79 ++--
glib/glibmm/wrap_init.h | 3 -
44 files changed, 2316 insertions(+), 2261 deletions(-)
---
diff --git a/glib/glibmm/arrayhandle.h b/glib/glibmm/arrayhandle.h
index e92223f..19454cb 100644
--- a/glib/glibmm/arrayhandle.h
+++ b/glib/glibmm/arrayhandle.h
@@ -32,12 +32,13 @@ namespace Container_Helpers
/* Count the number of elements in a 0-terminated sequence.
*/
-template <class T> inline
-std::size_t compute_array_size(const T* array)
+template <class T>
+inline std::size_t
+compute_array_size(const T* array)
{
const T* pend = array;
- while(*pend)
+ while (*pend)
++pend;
return (pend - array);
@@ -47,14 +48,15 @@ std::size_t compute_array_size(const T* array)
* specifies the number of elements in the input sequence.
*/
template <class For, class Tr>
-typename Tr::CType* create_array(For pbegin, std::size_t size, Tr)
+typename Tr::CType*
+create_array(For pbegin, std::size_t size, Tr)
{
typedef typename Tr::CType CType;
- CType *const array = static_cast<CType*>(g_malloc((size + 1) * sizeof(CType)));
- CType *const array_end = array + size;
+ CType* const array = static_cast<CType*>(g_malloc((size + 1) * sizeof(CType)));
+ CType* const array_end = array + size;
- for(CType* pdest = array; pdest != array_end; ++pdest)
+ for (CType* pdest = array; pdest != array_end; ++pdest)
{
// Use & to force a warning if the iterator returns a temporary object.
*pdest = Tr::to_c_type(*&*pbegin);
@@ -66,12 +68,13 @@ typename Tr::CType* create_array(For pbegin, std::size_t size, Tr)
}
template <class For>
-gboolean* create_bool_array(For pbegin, std::size_t size)
+gboolean*
+create_bool_array(For pbegin, std::size_t size)
{
- gboolean *const array(static_cast<gboolean*>(g_malloc((size + 1) * sizeof(gboolean))));
- gboolean *const array_end(array + size);
+ gboolean* const array(static_cast<gboolean*>(g_malloc((size + 1) * sizeof(gboolean))));
+ gboolean* const array_end(array + size);
- for(gboolean* pdest(array); pdest != array_end; ++pdest)
+ for (gboolean* pdest(array); pdest != array_end; ++pdest)
{
*pdest = *pbegin;
++pbegin;
@@ -89,11 +92,12 @@ struct ArraySourceTraits
{
typedef typename Tr::CType CType;
- static std::size_t get_size(const Cont& cont)
- { return cont.size(); }
+ static std::size_t get_size(const Cont& cont) { return cont.size(); }
static const CType* get_data(const Cont& cont, std::size_t size)
- { return Glib::Container_Helpers::create_array(cont.begin(), size, Tr()); }
+ {
+ return Glib::Container_Helpers::create_array(cont.begin(), size, Tr());
+ }
static const Glib::OwnershipType initial_ownership = Glib::OWNERSHIP_SHALLOW;
};
@@ -104,11 +108,12 @@ struct BoolArraySourceTraits
{
typedef gboolean CType;
- static std::size_t get_size(const Cont& cont)
- { return cont.size(); }
+ static std::size_t get_size(const Cont& cont) { return cont.size(); }
static const CType* get_data(const Cont& cont, std::size_t size)
- { return Glib::Container_Helpers::create_bool_array(cont.begin(), size); }
+ {
+ return Glib::Container_Helpers::create_bool_array(cont.begin(), size);
+ }
static const Glib::OwnershipType initial_ownership = Glib::OWNERSHIP_SHALLOW;
};
@@ -116,22 +121,24 @@ struct BoolArraySourceTraits
* to the first element. Note that only arrays of the C type are supported.
*/
template <class Tr, class Cont>
-struct ArraySourceTraits<Tr,Cont*>
+struct ArraySourceTraits<Tr, Cont*>
{
typedef typename Tr::CType CType;
static std::size_t get_size(const CType* array)
- { return (array) ? Glib::Container_Helpers::compute_array_size(array) : 0; }
+ {
+ return (array) ? Glib::Container_Helpers::compute_array_size(array) : 0;
+ }
- static const CType* get_data(const CType* array, std::size_t)
- { return array; }
+ static const CType* get_data(const CType* array, std::size_t) { return array; }
static const Glib::OwnershipType initial_ownership = Glib::OWNERSHIP_NONE;
};
template <class Tr, class Cont>
-struct ArraySourceTraits<Tr,const Cont*> : ArraySourceTraits<Tr,Cont*>
-{};
+struct ArraySourceTraits<Tr, const Cont*> : ArraySourceTraits<Tr, Cont*>
+{
+};
/* Convert from a 0-terminated array. The Cont argument must be a pointer
* to the first element. Note that only arrays of the C type are supported.
@@ -139,26 +146,24 @@ struct ArraySourceTraits<Tr,const Cont*> : ArraySourceTraits<Tr,Cont*>
* size is known at compile time.
*/
template <class Tr, class Cont, std::size_t N>
-struct ArraySourceTraits<Tr,Cont[N]>
+struct ArraySourceTraits<Tr, Cont[N]>
{
typedef typename Tr::CType CType;
- static std::size_t get_size(const CType*)
- { return (N - 1); }
+ static std::size_t get_size(const CType*) { return (N - 1); }
- static const CType* get_data(const CType* array, std::size_t)
- { return array; }
+ static const CType* get_data(const CType* array, std::size_t) { return array; }
static const Glib::OwnershipType initial_ownership = Glib::OWNERSHIP_NONE;
};
template <class Tr, class Cont, std::size_t N>
-struct ArraySourceTraits<Tr,const Cont[N]> : ArraySourceTraits<Tr,Cont[N]>
-{};
+struct ArraySourceTraits<Tr, const Cont[N]> : ArraySourceTraits<Tr, Cont[N]>
+{
+};
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
/**
* @ingroup ContHelpers
*/
@@ -166,40 +171,40 @@ template <class Tr>
class ArrayHandleIterator
{
public:
- typedef typename Tr::CppType CppType;
- typedef typename Tr::CType CType;
+ typedef typename Tr::CppType CppType;
+ typedef typename Tr::CType CType;
- typedef std::random_access_iterator_tag iterator_category;
- typedef CppType value_type;
- typedef std::ptrdiff_t difference_type;
- typedef value_type reference;
- typedef void pointer;
+ typedef std::random_access_iterator_tag iterator_category;
+ typedef CppType value_type;
+ typedef std::ptrdiff_t difference_type;
+ typedef value_type reference;
+ typedef void pointer;
explicit inline ArrayHandleIterator(const CType* pos);
inline value_type operator*() const;
inline value_type operator[](difference_type offset) const;
- inline ArrayHandleIterator<Tr> & operator++();
+ inline ArrayHandleIterator<Tr>& operator++();
inline const ArrayHandleIterator<Tr> operator++(int);
// these are needed by msvc 2005 when using deque.
- inline ArrayHandleIterator<Tr> & operator--();
+ inline ArrayHandleIterator<Tr>& operator--();
inline const ArrayHandleIterator<Tr> operator--(int);
// All this random access stuff is only there because STL algorithms
// usually have optimized specializations for random access iterators,
// and we don't want to give away efficiency for nothing.
//
- inline ArrayHandleIterator<Tr> & operator+=(difference_type rhs);
- inline ArrayHandleIterator<Tr> & operator-=(difference_type rhs);
- inline const ArrayHandleIterator<Tr> operator+ (difference_type rhs) const;
- inline const ArrayHandleIterator<Tr> operator- (difference_type rhs) const;
+ inline ArrayHandleIterator<Tr>& operator+=(difference_type rhs);
+ inline ArrayHandleIterator<Tr>& operator-=(difference_type rhs);
+ inline const ArrayHandleIterator<Tr> operator+(difference_type rhs) const;
+ inline const ArrayHandleIterator<Tr> operator-(difference_type rhs) const;
inline difference_type operator-(const ArrayHandleIterator<Tr>& rhs) const;
inline bool operator==(const ArrayHandleIterator<Tr>& rhs) const;
inline bool operator!=(const ArrayHandleIterator<Tr>& rhs) const;
- inline bool operator< (const ArrayHandleIterator<Tr>& rhs) const;
- inline bool operator> (const ArrayHandleIterator<Tr>& rhs) const;
+ inline bool operator<(const ArrayHandleIterator<Tr>& rhs) const;
+ inline bool operator>(const ArrayHandleIterator<Tr>& rhs) const;
inline bool operator<=(const ArrayHandleIterator<Tr>& rhs) const;
inline bool operator>=(const ArrayHandleIterator<Tr>& rhs) const;
@@ -209,9 +214,8 @@ private:
} // namespace Container_Helpers
-
-//TODO: When we can break ABI, remove this and replace uses of it with std::vector.
-//We cannot deprecate it yet, because we cannot easily deprecate methods that use it
+// TODO: When we can break ABI, remove this and replace uses of it with std::vector.
+// We cannot deprecate it yet, because we cannot easily deprecate methods that use it
//- for instance, we cannot just override methods that use it as a return type.
/** This is an intermediate type. When a method takes this, or returns this, you
@@ -223,77 +227,80 @@ private:
*
* @ingroup ContHandles
*/
-template < class T, class Tr = Glib::Container_Helpers::TypeTraits<T> >
+template <class T, class Tr = Glib::Container_Helpers::TypeTraits<T>>
class ArrayHandle
{
public:
- typedef typename Tr::CppType CppType;
- typedef typename Tr::CType CType;
+ typedef typename Tr::CppType CppType;
+ typedef typename Tr::CType CType;
- typedef CppType value_type;
- typedef std::size_t size_type;
- typedef std::ptrdiff_t difference_type;
+ typedef CppType value_type;
+ typedef std::size_t size_type;
+ typedef std::ptrdiff_t difference_type;
- typedef Glib::Container_Helpers::ArrayHandleIterator<Tr> const_iterator;
- typedef Glib::Container_Helpers::ArrayHandleIterator<Tr> iterator;
+ typedef Glib::Container_Helpers::ArrayHandleIterator<Tr> const_iterator;
+ typedef Glib::Container_Helpers::ArrayHandleIterator<Tr> iterator;
- template <class Cont> inline
- ArrayHandle(const Cont& container);
+ template <class Cont>
+ inline ArrayHandle(const Cont& container);
// Take over ownership of an array created by GTK+ functions.
inline ArrayHandle(const CType* array, std::size_t array_size, Glib::OwnershipType ownership);
inline ArrayHandle(const CType* array, Glib::OwnershipType ownership);
// Copying clears the ownership flag of the source handle.
- inline ArrayHandle(const ArrayHandle<T,Tr>& other);
+ inline ArrayHandle(const ArrayHandle<T, Tr>& other);
~ArrayHandle() noexcept;
inline const_iterator begin() const;
- inline const_iterator end() const;
+ inline const_iterator end() const;
- template <class U> inline operator std::vector<U>() const;
- template <class U> inline operator std::deque<U>() const;
- template <class U> inline operator std::list<U>() const;
+ template <class U>
+ inline operator std::vector<U>() const;
+ template <class U>
+ inline operator std::deque<U>() const;
+ template <class U>
+ inline operator std::list<U>() const;
- template <class Cont> inline
- void assign_to(Cont& container) const;
+ template <class Cont>
+ inline void assign_to(Cont& container) const;
- template <class Out> inline
- void copy(Out pdest) const;
+ template <class Out>
+ inline void copy(Out pdest) const;
- inline const CType* data() const;
- inline std::size_t size() const;
- inline bool empty() const;
+ inline const CType* data() const;
+ inline std::size_t size() const;
+ inline bool empty() const;
private:
- std::size_t size_;
- const CType* parray_;
+ std::size_t size_;
+ const CType* parray_;
mutable Glib::OwnershipType ownership_;
// No copy assignment.
- ArrayHandle<T, Tr>& operator=(const ArrayHandle<T,Tr>&);
+ ArrayHandle<T, Tr>& operator=(const ArrayHandle<T, Tr>&);
};
-template<>
-class ArrayHandle<bool, Container_Helpers::TypeTraits<bool> >
+template <>
+class ArrayHandle<bool, Container_Helpers::TypeTraits<bool>>
{
public:
- typedef ArrayHandle<bool, Container_Helpers::TypeTraits<bool> > Me;
- typedef Container_Helpers::TypeTraits<bool> Tr;
+ typedef ArrayHandle<bool, Container_Helpers::TypeTraits<bool>> Me;
+ typedef Container_Helpers::TypeTraits<bool> Tr;
- typedef Tr::CppType CppType;
- typedef Tr::CType CType;
+ typedef Tr::CppType CppType;
+ typedef Tr::CType CType;
- typedef CppType value_type;
- typedef std::size_t size_type;
- typedef std::ptrdiff_t difference_type;
+ typedef CppType value_type;
+ typedef std::size_t size_type;
+ typedef std::ptrdiff_t difference_type;
- typedef Glib::Container_Helpers::ArrayHandleIterator<Tr> const_iterator;
- typedef Glib::Container_Helpers::ArrayHandleIterator<Tr> iterator;
+ typedef Glib::Container_Helpers::ArrayHandleIterator<Tr> const_iterator;
+ typedef Glib::Container_Helpers::ArrayHandleIterator<Tr> iterator;
- template <class Cont> inline
- ArrayHandle(const Cont& container);
+ template <class Cont>
+ inline ArrayHandle(const Cont& container);
// Take over ownership of an array created by GTK+ functions.
inline ArrayHandle(const CType* array, std::size_t array_size, Glib::OwnershipType ownership);
@@ -305,10 +312,11 @@ public:
~ArrayHandle() noexcept;
inline const_iterator begin() const;
- inline const_iterator end() const;
+ inline const_iterator end() const;
// this is inside class definition, so msvc 2005, 2008 and 2010 can compile this code.
- template <class U> inline operator std::vector<U>() const
+ template <class U>
+ inline operator std::vector<U>() const
{
#ifdef GLIBMM_HAVE_TEMPLATE_SEQUENCE_CTORS
return std::vector<U>(this->begin(), this->end());
@@ -321,7 +329,8 @@ public:
}
// this is inside class definition, so msvc 2005, 2008 and 2010 can compile this code.
- template <class U> inline operator std::deque<U>() const
+ template <class U>
+ inline operator std::deque<U>() const
{
#ifdef GLIBMM_HAVE_TEMPLATE_SEQUENCE_CTORS
return std::deque<U>(this->begin(), this->end());
@@ -333,7 +342,8 @@ public:
}
// this is inside class definition, so msvc 2005, 2008 and 2010 can compile this code.
- template <class U> inline operator std::list<U>() const
+ template <class U>
+ inline operator std::list<U>() const
{
#ifdef GLIBMM_HAVE_TEMPLATE_SEQUENCE_CTORS
return std::list<U>(this->begin(), this->end());
@@ -344,26 +354,26 @@ public:
#endif
}
- template <class Cont> inline
- void assign_to(Cont& container) const;
+ template <class Cont>
+ inline void assign_to(Cont& container) const;
- template <class Out> inline
- void copy(Out pdest) const;
+ template <class Out>
+ inline void copy(Out pdest) const;
- inline const CType* data() const;
- inline std::size_t size() const;
- inline bool empty() const;
+ inline const CType* data() const;
+ inline std::size_t size() const;
+ inline bool empty() const;
private:
- std::size_t size_;
- const CType* parray_;
+ std::size_t size_;
+ const CType* parray_;
mutable Glib::OwnershipType ownership_;
// No copy assignment.
Me& operator=(const Me&);
};
-//TODO: Remove this when we can break glibmm API.
+// TODO: Remove this when we can break glibmm API.
/** If a method takes this as an argument, or has this as a return type, then you can use a standard
* container such as std::list<Glib::ustring> or std::vector<Glib::ustring>.
*
@@ -375,7 +385,6 @@ private:
*/
typedef ArrayHandle<Glib::ustring> StringArrayHandle;
-
/***************************************************************************/
/* Inline implementation */
/***************************************************************************/
@@ -387,199 +396,198 @@ namespace Container_Helpers
/**** Glib::Container_Helpers::ArrayHandleIterator<> ***********************/
-template <class Tr> inline
-ArrayHandleIterator<Tr>::ArrayHandleIterator(const CType* pos)
-:
- pos_ (pos)
-{}
+template <class Tr>
+inline ArrayHandleIterator<Tr>::ArrayHandleIterator(const CType* pos) : pos_(pos)
+{
+}
-template <class Tr> inline
-typename ArrayHandleIterator<Tr>::value_type ArrayHandleIterator<Tr>::operator*() const
+template <class Tr>
+inline typename ArrayHandleIterator<Tr>::value_type ArrayHandleIterator<Tr>::operator*() const
{
return Tr::to_cpp_type(*pos_);
}
-template <class Tr> inline
-typename ArrayHandleIterator<Tr>::value_type
-ArrayHandleIterator<Tr>::operator[](difference_type offset) const
+template <class Tr>
+inline typename ArrayHandleIterator<Tr>::value_type ArrayHandleIterator<Tr>::operator[](
+ difference_type offset) const
{
return Tr::to_cpp_type(pos_[offset]);
}
-template <class Tr> inline
-ArrayHandleIterator<Tr>& ArrayHandleIterator<Tr>::operator++()
+template <class Tr>
+inline ArrayHandleIterator<Tr>& ArrayHandleIterator<Tr>::operator++()
{
++pos_;
return *this;
}
-template <class Tr> inline
-const ArrayHandleIterator<Tr> ArrayHandleIterator<Tr>::operator++(int)
+template <class Tr>
+inline const ArrayHandleIterator<Tr> ArrayHandleIterator<Tr>::operator++(int)
{
return ArrayHandleIterator<Tr>(pos_++);
}
-template <class Tr> inline
-ArrayHandleIterator<Tr>& ArrayHandleIterator<Tr>::operator--()
+template <class Tr>
+inline ArrayHandleIterator<Tr>& ArrayHandleIterator<Tr>::operator--()
{
--pos_;
return *this;
}
-template <class Tr> inline
-const ArrayHandleIterator<Tr> ArrayHandleIterator<Tr>::operator--(int)
+template <class Tr>
+inline const ArrayHandleIterator<Tr> ArrayHandleIterator<Tr>::operator--(int)
{
return ArrayHandleIterator<Tr>(pos_--);
}
-template <class Tr> inline
-ArrayHandleIterator<Tr>&
+template <class Tr>
+inline ArrayHandleIterator<Tr>&
ArrayHandleIterator<Tr>::operator+=(typename ArrayHandleIterator<Tr>::difference_type rhs)
{
pos_ += rhs;
return *this;
}
-template <class Tr> inline
-ArrayHandleIterator<Tr>&
+template <class Tr>
+inline ArrayHandleIterator<Tr>&
ArrayHandleIterator<Tr>::operator-=(typename ArrayHandleIterator<Tr>::difference_type rhs)
{
pos_ -= rhs;
return *this;
}
-template <class Tr> inline
-const ArrayHandleIterator<Tr>
+template <class Tr>
+inline const ArrayHandleIterator<Tr>
ArrayHandleIterator<Tr>::operator+(typename ArrayHandleIterator<Tr>::difference_type rhs) const
{
return ArrayHandleIterator<Tr>(pos_ + rhs);
}
-template <class Tr> inline
-const ArrayHandleIterator<Tr>
+template <class Tr>
+inline const ArrayHandleIterator<Tr>
ArrayHandleIterator<Tr>::operator-(typename ArrayHandleIterator<Tr>::difference_type rhs) const
{
return ArrayHandleIterator<Tr>(pos_ - rhs);
}
-template <class Tr> inline
-typename ArrayHandleIterator<Tr>::difference_type
+template <class Tr>
+inline typename ArrayHandleIterator<Tr>::difference_type
ArrayHandleIterator<Tr>::operator-(const ArrayHandleIterator<Tr>& rhs) const
{
return (pos_ - rhs.pos_);
}
-template <class Tr> inline
-bool ArrayHandleIterator<Tr>::operator==(const ArrayHandleIterator<Tr>& rhs) const
+template <class Tr>
+inline bool
+ArrayHandleIterator<Tr>::operator==(const ArrayHandleIterator<Tr>& rhs) const
{
return (pos_ == rhs.pos_);
}
-template <class Tr> inline
-bool ArrayHandleIterator<Tr>::operator!=(const ArrayHandleIterator<Tr>& rhs) const
+template <class Tr>
+inline bool
+ArrayHandleIterator<Tr>::operator!=(const ArrayHandleIterator<Tr>& rhs) const
{
return (pos_ != rhs.pos_);
}
-template <class Tr> inline
-bool ArrayHandleIterator<Tr>::operator<(const ArrayHandleIterator<Tr>& rhs) const
+template <class Tr>
+inline bool
+ArrayHandleIterator<Tr>::operator<(const ArrayHandleIterator<Tr>& rhs) const
{
return (pos_ < rhs.pos_);
}
-template <class Tr> inline
-bool ArrayHandleIterator<Tr>::operator>(const ArrayHandleIterator<Tr>& rhs) const
+template <class Tr>
+inline bool
+ArrayHandleIterator<Tr>::operator>(const ArrayHandleIterator<Tr>& rhs) const
{
return (pos_ > rhs.pos_);
}
-template <class Tr> inline
-bool ArrayHandleIterator<Tr>::operator<=(const ArrayHandleIterator<Tr>& rhs) const
+template <class Tr>
+inline bool
+ArrayHandleIterator<Tr>::operator<=(const ArrayHandleIterator<Tr>& rhs) const
{
return (pos_ <= rhs.pos_);
}
-template <class Tr> inline
-bool ArrayHandleIterator<Tr>::operator>=(const ArrayHandleIterator<Tr>& rhs) const
+template <class Tr>
+inline bool
+ArrayHandleIterator<Tr>::operator>=(const ArrayHandleIterator<Tr>& rhs) const
{
return (pos_ >= rhs.pos_);
}
} // namespace Container_Helpers
-
/**** Glib::ArrayHandle<> **************************************************/
template <class T, class Tr>
- template <class Cont>
-inline
-ArrayHandle<T,Tr>::ArrayHandle(const Cont& container)
-:
- size_ (Glib::Container_Helpers::ArraySourceTraits<Tr,Cont>::get_size(container)),
- parray_ (Glib::Container_Helpers::ArraySourceTraits<Tr,Cont>::get_data(container, size_)),
- ownership_ (Glib::Container_Helpers::ArraySourceTraits<Tr,Cont>::initial_ownership)
-{}
-
-template <class T, class Tr> inline
-ArrayHandle<T,Tr>::ArrayHandle(const typename ArrayHandle<T,Tr>::CType* array, std::size_t array_size,
- Glib::OwnershipType ownership)
-:
- size_ ((array) ? array_size : 0),
- parray_ (array),
- ownership_ (ownership)
-{}
-
-template <class T, class Tr> inline
-ArrayHandle<T,Tr>::ArrayHandle(const typename ArrayHandle<T,Tr>::CType* array,
- Glib::OwnershipType ownership)
-:
- size_ ((array) ? Glib::Container_Helpers::compute_array_size(array) : 0),
- parray_ (array),
- ownership_ (ownership)
-{}
-
-template <class T, class Tr> inline
-ArrayHandle<T,Tr>::ArrayHandle(const ArrayHandle<T,Tr>& other)
-:
- size_ (other.size_),
- parray_ (other.parray_),
- ownership_ (other.ownership_)
+template <class Cont>
+inline ArrayHandle<T, Tr>::ArrayHandle(const Cont& container)
+: size_(Glib::Container_Helpers::ArraySourceTraits<Tr, Cont>::get_size(container)),
+ parray_(Glib::Container_Helpers::ArraySourceTraits<Tr, Cont>::get_data(container, size_)),
+ ownership_(Glib::Container_Helpers::ArraySourceTraits<Tr, Cont>::initial_ownership)
+{
+}
+
+template <class T, class Tr>
+inline ArrayHandle<T, Tr>::ArrayHandle(const typename ArrayHandle<T, Tr>::CType* array,
+ std::size_t array_size, Glib::OwnershipType ownership)
+: size_((array) ? array_size : 0), parray_(array), ownership_(ownership)
+{
+}
+
+template <class T, class Tr>
+inline ArrayHandle<T, Tr>::ArrayHandle(
+ const typename ArrayHandle<T, Tr>::CType* array, Glib::OwnershipType ownership)
+: size_((array) ? Glib::Container_Helpers::compute_array_size(array) : 0),
+ parray_(array),
+ ownership_(ownership)
+{
+}
+
+template <class T, class Tr>
+inline ArrayHandle<T, Tr>::ArrayHandle(const ArrayHandle<T, Tr>& other)
+: size_(other.size_), parray_(other.parray_), ownership_(other.ownership_)
{
other.ownership_ = Glib::OWNERSHIP_NONE;
}
template <class T, class Tr>
-ArrayHandle<T,Tr>::~ArrayHandle() noexcept
+ArrayHandle<T, Tr>::~ArrayHandle() noexcept
{
- if(parray_ && ownership_ != Glib::OWNERSHIP_NONE)
+ if (parray_ && ownership_ != Glib::OWNERSHIP_NONE)
{
- if(ownership_ != Glib::OWNERSHIP_SHALLOW)
+ if (ownership_ != Glib::OWNERSHIP_SHALLOW)
{
// Deep ownership: release each container element.
- const CType *const pend = parray_ + size_;
- for(const CType* p = parray_; p != pend; ++p)
+ const CType* const pend = parray_ + size_;
+ for (const CType* p = parray_; p != pend; ++p)
Tr::release_c_type(*p);
}
g_free(const_cast<CType*>(parray_));
}
}
-template <class T, class Tr> inline
-typename ArrayHandle<T,Tr>::const_iterator ArrayHandle<T,Tr>::begin() const
+template <class T, class Tr>
+inline typename ArrayHandle<T, Tr>::const_iterator
+ArrayHandle<T, Tr>::begin() const
{
return Glib::Container_Helpers::ArrayHandleIterator<Tr>(parray_);
}
-template <class T, class Tr> inline
-typename ArrayHandle<T,Tr>::const_iterator ArrayHandle<T,Tr>::end() const
+template <class T, class Tr>
+inline typename ArrayHandle<T, Tr>::const_iterator
+ArrayHandle<T, Tr>::end() const
{
return Glib::Container_Helpers::ArrayHandleIterator<Tr>(parray_ + size_);
}
template <class T, class Tr>
- template <class U>
-inline
-ArrayHandle<T,Tr>::operator std::vector<U>() const
+template <class U>
+inline ArrayHandle<T, Tr>::operator std::vector<U>() const
{
#ifdef GLIBMM_HAVE_TEMPLATE_SEQUENCE_CTORS
return std::vector<U>(this->begin(), this->end());
@@ -592,9 +600,8 @@ ArrayHandle<T,Tr>::operator std::vector<U>() const
}
template <class T, class Tr>
- template <class U>
-inline
-ArrayHandle<T,Tr>::operator std::deque<U>() const
+template <class U>
+inline ArrayHandle<T, Tr>::operator std::deque<U>() const
{
#ifdef GLIBMM_HAVE_TEMPLATE_SEQUENCE_CTORS
return std::deque<U>(this->begin(), this->end());
@@ -606,9 +613,8 @@ ArrayHandle<T,Tr>::operator std::deque<U>() const
}
template <class T, class Tr>
- template <class U>
-inline
-ArrayHandle<T,Tr>::operator std::list<U>() const
+template <class U>
+inline ArrayHandle<T, Tr>::operator std::list<U>() const
{
#ifdef GLIBMM_HAVE_TEMPLATE_SEQUENCE_CTORS
return std::list<U>(this->begin(), this->end());
@@ -620,9 +626,9 @@ ArrayHandle<T,Tr>::operator std::list<U>() const
}
template <class T, class Tr>
- template <class Cont>
-inline
-void ArrayHandle<T,Tr>::assign_to(Cont& container) const
+template <class Cont>
+inline void
+ArrayHandle<T, Tr>::assign_to(Cont& container) const
{
#ifdef GLIBMM_HAVE_TEMPLATE_SEQUENCE_CTORS
container.assign(this->begin(), this->end());
@@ -634,86 +640,80 @@ void ArrayHandle<T,Tr>::assign_to(Cont& container) const
}
template <class T, class Tr>
- template <class Out>
-inline
-void ArrayHandle<T,Tr>::copy(Out pdest) const
+template <class Out>
+inline void
+ArrayHandle<T, Tr>::copy(Out pdest) const
{
std::copy(this->begin(), this->end(), pdest);
}
-template <class T, class Tr> inline
-const typename ArrayHandle<T,Tr>::CType* ArrayHandle<T,Tr>::data() const
+template <class T, class Tr>
+inline const typename ArrayHandle<T, Tr>::CType*
+ArrayHandle<T, Tr>::data() const
{
return parray_;
}
-template <class T, class Tr> inline
-std::size_t ArrayHandle<T,Tr>::size() const
+template <class T, class Tr>
+inline std::size_t
+ArrayHandle<T, Tr>::size() const
{
return size_;
}
-template <class T, class Tr> inline
-bool ArrayHandle<T,Tr>::empty() const
+template <class T, class Tr>
+inline bool
+ArrayHandle<T, Tr>::empty() const
{
return (size_ == 0);
}
-
/**** Glib::ArrayHandle<bool> **********************************************/
template <class Cont>
-inline
-ArrayHandle<bool,Container_Helpers::TypeTraits<bool> >::ArrayHandle(const Cont& container)
-:
- size_ (Glib::Container_Helpers::BoolArraySourceTraits<Cont>::get_size(container)),
- parray_ (Glib::Container_Helpers::BoolArraySourceTraits<Cont>::get_data(container, size_)),
- ownership_ (Glib::Container_Helpers::BoolArraySourceTraits<Cont>::initial_ownership)
-{}
-
-inline
-ArrayHandle<bool,Container_Helpers::TypeTraits<bool> >::ArrayHandle(const gboolean* array, std::size_t
array_size,
- Glib::OwnershipType ownership)
-:
- size_ ((array) ? array_size : 0),
- parray_ (array),
- ownership_ (ownership)
-{}
-
-inline
-ArrayHandle<bool,Container_Helpers::TypeTraits<bool> >::ArrayHandle(const gboolean* array,
- Glib::OwnershipType ownership)
-:
- size_ ((array) ? Glib::Container_Helpers::compute_array_size(array) : 0),
- parray_ (array),
- ownership_ (ownership)
-{}
-
-inline
-ArrayHandle<bool,Container_Helpers::TypeTraits<bool> >::ArrayHandle(const
ArrayHandle<bool,Container_Helpers::TypeTraits<bool> >& other)
-:
- size_ (other.size_),
- parray_ (other.parray_),
- ownership_ (other.ownership_)
+inline ArrayHandle<bool, Container_Helpers::TypeTraits<bool>>::ArrayHandle(const Cont& container)
+: size_(Glib::Container_Helpers::BoolArraySourceTraits<Cont>::get_size(container)),
+ parray_(Glib::Container_Helpers::BoolArraySourceTraits<Cont>::get_data(container, size_)),
+ ownership_(Glib::Container_Helpers::BoolArraySourceTraits<Cont>::initial_ownership)
+{
+}
+
+inline ArrayHandle<bool, Container_Helpers::TypeTraits<bool>>::ArrayHandle(
+ const gboolean* array, std::size_t array_size, Glib::OwnershipType ownership)
+: size_((array) ? array_size : 0), parray_(array), ownership_(ownership)
+{
+}
+
+inline ArrayHandle<bool, Container_Helpers::TypeTraits<bool>>::ArrayHandle(
+ const gboolean* array, Glib::OwnershipType ownership)
+: size_((array) ? Glib::Container_Helpers::compute_array_size(array) : 0),
+ parray_(array),
+ ownership_(ownership)
+{
+}
+
+inline ArrayHandle<bool, Container_Helpers::TypeTraits<bool>>::ArrayHandle(
+ const ArrayHandle<bool, Container_Helpers::TypeTraits<bool>>& other)
+: size_(other.size_), parray_(other.parray_), ownership_(other.ownership_)
{
other.ownership_ = Glib::OWNERSHIP_NONE;
}
-inline
-ArrayHandle<bool,Container_Helpers::TypeTraits<bool> >::const_iterator
ArrayHandle<bool,Container_Helpers::TypeTraits<bool> >::begin() const
+inline ArrayHandle<bool, Container_Helpers::TypeTraits<bool>>::const_iterator
+ArrayHandle<bool, Container_Helpers::TypeTraits<bool>>::begin() const
{
return Glib::Container_Helpers::ArrayHandleIterator<Tr>(parray_);
}
-inline
-ArrayHandle<bool,Container_Helpers::TypeTraits<bool> >::const_iterator
ArrayHandle<bool,Container_Helpers::TypeTraits<bool> >::end() const
+inline ArrayHandle<bool, Container_Helpers::TypeTraits<bool>>::const_iterator
+ArrayHandle<bool, Container_Helpers::TypeTraits<bool>>::end() const
{
return Glib::Container_Helpers::ArrayHandleIterator<Tr>(parray_ + size_);
}
template <class Cont>
-inline
-void ArrayHandle<bool,Container_Helpers::TypeTraits<bool> >::assign_to(Cont& container) const
+inline void
+ArrayHandle<bool, Container_Helpers::TypeTraits<bool>>::assign_to(Cont& container) const
{
#ifdef GLIBMM_HAVE_TEMPLATE_SEQUENCE_CTORS
container.assign(this->begin(), this->end());
@@ -725,26 +725,26 @@ void ArrayHandle<bool,Container_Helpers::TypeTraits<bool> >::assign_to(Cont& con
}
template <class Out>
-inline
-void ArrayHandle<bool,Container_Helpers::TypeTraits<bool> >::copy(Out pdest) const
+inline void
+ArrayHandle<bool, Container_Helpers::TypeTraits<bool>>::copy(Out pdest) const
{
std::copy(this->begin(), this->end(), pdest);
}
-inline
-const gboolean* ArrayHandle<bool,Container_Helpers::TypeTraits<bool> >::data() const
+inline const gboolean*
+ArrayHandle<bool, Container_Helpers::TypeTraits<bool>>::data() const
{
return parray_;
}
-inline
-std::size_t ArrayHandle<bool,Container_Helpers::TypeTraits<bool> >::size() const
+inline std::size_t
+ArrayHandle<bool, Container_Helpers::TypeTraits<bool>>::size() const
{
return size_;
}
-inline
-bool ArrayHandle<bool,Container_Helpers::TypeTraits<bool> >::empty() const
+inline bool
+ArrayHandle<bool, Container_Helpers::TypeTraits<bool>>::empty() const
{
return (size_ == 0);
}
@@ -753,6 +753,4 @@ bool ArrayHandle<bool,Container_Helpers::TypeTraits<bool> >::empty() const
} // namespace Glib
-
#endif /* _GLIBMM_ARRAYHANDLE_H */
-
diff --git a/glib/glibmm/base64.h b/glib/glibmm/base64.h
index d5ec413..eda3da0 100644
--- a/glib/glibmm/base64.h
+++ b/glib/glibmm/base64.h
@@ -48,13 +48,10 @@ std::string encode(const std::string& source, bool break_lines = false);
* @return The resulting decode string
*/
std::string decode(const std::string& source);
-
}
/** @} group Base64 */
} // namespace Glib
-
#endif /* _GLIBMM_BASE64_H */
-
diff --git a/glib/glibmm/class.h b/glib/glibmm/class.h
index d43f7ce..691c1bf 100644
--- a/glib/glibmm/class.h
+++ b/glib/glibmm/class.h
@@ -42,19 +42,19 @@ public:
* because the C/C++ standard explicitly specifies that all _static_ data
* is zero-initialized at program start.
*/
- //Class();
+ // Class();
//~Class() noexcept;
- //static void class_init_function(BaseClassType *p);
- //static void object_init_function(BaseObjectType *o);
- //GType get_type() = 0; //Creates the GType when this is first called.
+ // static void class_init_function(BaseClassType *p);
+ // static void object_init_function(BaseObjectType *o);
+ // GType get_type() = 0; //Creates the GType when this is first called.
// Hook for translating API
- //static Glib::Object* wrap_new(GObject*);
+ // static Glib::Object* wrap_new(GObject*);
inline GType get_type() const;
- //TODO: Remove this method at the next ABI/API break.
+ // TODO: Remove this method at the next ABI/API break.
/** Register a static custom GType, derived from the parent of this class's type.
* The parent type of the registered custom type is the same C class as the parent
* of the get_type() type. If a type with the specified name is already registered,
@@ -79,19 +79,20 @@ public:
* @param interface_classes Interfaces that the custom type implements.
* @return The registered type.
*/
- GType clone_custom_type(const char* custom_type_name,
- const interface_class_vector_type& interface_classes) const;
+ GType clone_custom_type(
+ const char* custom_type_name, const interface_class_vector_type& interface_classes) const;
protected:
- GType gtype_;
- GClassInitFunc class_init_func_;
+ GType gtype_;
+ GClassInitFunc class_init_func_;
/** Register a GType, derived from the @a base_type.
*/
void register_derived_type(GType base_type);
/** Register a GType, derived from the @a base_type.
- * @param module If this is not 0 then g_type_module_register_type() will be used. Otherwise
g_type_register_static() will be used.
+ * @param module If this is not 0 then g_type_module_register_type() will be used. Otherwise
+ * g_type_register_static() will be used.
*/
void register_derived_type(GType base_type, GTypeModule* module);
@@ -108,8 +109,8 @@ public:
#endif
};
-inline
-GType Class::get_type() const
+inline GType
+Class::get_type() const
{
return gtype_;
}
@@ -119,4 +120,3 @@ GType Class::get_type() const
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
#endif /* _GLIBMM_CLASS_H */
-
diff --git a/glib/glibmm/containerhandle_shared.h b/glib/glibmm/containerhandle_shared.h
index 4d5a552..77c54c1 100644
--- a/glib/glibmm/containerhandle_shared.h
+++ b/glib/glibmm/containerhandle_shared.h
@@ -50,11 +50,10 @@ namespace Glib
enum OwnershipType
{
OWNERSHIP_NONE = 0, /*!< Do not release anything */
- OWNERSHIP_SHALLOW, /*!< Release the list, but not its elements, when the container is deleted */
- OWNERSHIP_DEEP /*!< Release the list, and its elements, when the container is deleted. */
+ OWNERSHIP_SHALLOW, /*!< Release the list, but not its elements, when the container is deleted */
+ OWNERSHIP_DEEP /*!< Release the list, and its elements, when the container is deleted. */
};
-
/** Utility class holding an iterator sequence.
* @ingroup ContHandles
* This can be used to initialize a Glib container handle (such as
@@ -69,12 +68,11 @@ private:
Iterator pend_;
public:
- Sequence(Iterator pbegin, Iterator pend)
- : pbegin_(pbegin), pend_(pend) {}
+ Sequence(Iterator pbegin, Iterator pend) : pbegin_(pbegin), pend_(pend) {}
Iterator begin() const { return pbegin_; }
- Iterator end() const { return pend_; }
- std::size_t size() const { return std::distance(pbegin_, pend_); }
+ Iterator end() const { return pend_; }
+ std::size_t size() const { return std::distance(pbegin_, pend_); }
};
/** Helper function to create a Glib::Sequence<> object, which
@@ -86,13 +84,13 @@ public:
* combo.set_popdown_strings(Glib::sequence(foo_begin, foo_end));
* @endcode
*/
-template <class Iterator> inline
-Sequence<Iterator> sequence(Iterator pbegin, Iterator pend)
+template <class Iterator>
+inline Sequence<Iterator>
+sequence(Iterator pbegin, Iterator pend)
{
return Sequence<Iterator>(pbegin, pend);
}
-
namespace Container_Helpers
{
@@ -113,15 +111,15 @@ struct TypeTraits
typedef T CType;
typedef T CTypeNonConst;
- static CType to_c_type (const CppType& item) { return item; }
- static CppType to_cpp_type (const CType& item) { return item; }
- static void release_c_type (const CType&) {}
+ static CType to_c_type(const CppType& item) { return item; }
+ static CppType to_cpp_type(const CType& item) { return item; }
+ static void release_c_type(const CType&) {}
};
#ifndef DOXYGEN_SHOULD_SKIP_THIS /* hide the specializations */
-//For some (probably, more spec-compliant) compilers, these specializations must
-//be next to the objects that they use.
+// For some (probably, more spec-compliant) compilers, these specializations must
+// be next to the objects that they use.
#ifdef GLIBMM_CAN_USE_DYNAMIC_CAST_IN_UNUSED_TEMPLATE_WITHOUT_DEFINITION
/** Partial specialization for pointers to GtkObject instances.
@@ -130,30 +128,30 @@ struct TypeTraits
template <class T>
struct TypeTraits<T*>
{
- typedef T * CppType;
- typedef typename T::BaseObjectType * CType;
- typedef typename T::BaseObjectType * CTypeNonConst;
+ typedef T* CppType;
+ typedef typename T::BaseObjectType* CType;
+ typedef typename T::BaseObjectType* CTypeNonConst;
- static CType to_c_type (CppType ptr) { return Glib::unwrap(ptr); }
- static CType to_c_type (CType ptr) { return ptr; }
- static CppType to_cpp_type (CType ptr)
+ static CType to_c_type(CppType ptr) { return Glib::unwrap(ptr); }
+ static CType to_c_type(CType ptr) { return ptr; }
+ static CppType to_cpp_type(CType ptr)
{
- //We copy/paste the widget wrap() implementation here,
- //because we can not use a specific Glib::wrap(T_Impl) overload here,
- //because that would be "dependent", and g++ 3.4 does not allow that.
- //The specific Glib::wrap() overloads don't do anything special anyway.
+ // We copy/paste the widget wrap() implementation here,
+ // because we can not use a specific Glib::wrap(T_Impl) overload here,
+ // because that would be "dependent", and g++ 3.4 does not allow that.
+ // The specific Glib::wrap() overloads don't do anything special anyway.
GObject* cobj = (GObject*)ptr;
return dynamic_cast<CppType>(Glib::wrap_auto(cobj, false /* take_copy */));
}
- static void release_c_type (CType ptr)
+ static void release_c_type(CType ptr)
{
GLIBMM_DEBUG_UNREFERENCE(nullptr, ptr);
g_object_unref(ptr);
}
};
-//This confuse the SUN Forte compiler, so we ifdef it out:
+// This confuse the SUN Forte compiler, so we ifdef it out:
#ifdef GLIBMM_HAVE_DISAMBIGUOUS_CONST_TEMPLATE_SPECIALIZATIONS
/** Partial specialization for pointers to const GtkObject instances.
@@ -162,64 +160,64 @@ struct TypeTraits<T*>
template <class T>
struct TypeTraits<const T*>
{
- typedef const T * CppType;
- typedef const typename T::BaseObjectType * CType;
- typedef typename T::BaseObjectType * CTypeNonConst;
+ typedef const T* CppType;
+ typedef const typename T::BaseObjectType* CType;
+ typedef typename T::BaseObjectType* CTypeNonConst;
- static CType to_c_type (CppType ptr) { return Glib::unwrap(ptr); }
- static CType to_c_type (CType ptr) { return ptr; }
- static CppType to_cpp_type (CType ptr)
+ static CType to_c_type(CppType ptr) { return Glib::unwrap(ptr); }
+ static CType to_c_type(CType ptr) { return ptr; }
+ static CppType to_cpp_type(CType ptr)
{
- //We copy/paste the widget wrap() implementation here,
- //because we can not use a specific Glib::wrap(T_Impl) overload here,
- //because that would be "dependent", and g++ 3.4 does not allow that.
- //The specific Glib::wrap() overloads don't do anything special anyway.
- GObject* cobj = (GObject*)const_cast<CTypeNonConst>(ptr);
- return dynamic_cast<CppType>(Glib::wrap_auto(cobj, false /* take_copy */));
+ // We copy/paste the widget wrap() implementation here,
+ // because we can not use a specific Glib::wrap(T_Impl) overload here,
+ // because that would be "dependent", and g++ 3.4 does not allow that.
+ // The specific Glib::wrap() overloads don't do anything special anyway.
+ GObject* cobj = (GObject*)const_cast<CTypeNonConst>(ptr);
+ return dynamic_cast<CppType>(Glib::wrap_auto(cobj, false /* take_copy */));
}
- static void release_c_type (CType ptr)
+ static void release_c_type(CType ptr)
{
GLIBMM_DEBUG_UNREFERENCE(nullptr, ptr);
g_object_unref(const_cast<CTypeNonConst>(ptr));
}
};
-#endif //GLIBMM_HAVE_DISAMBIGUOUS_CONST_TEMPLATE_SPECIALIZATIONS
+#endif // GLIBMM_HAVE_DISAMBIGUOUS_CONST_TEMPLATE_SPECIALIZATIONS
/** Partial specialization for pointers to GObject instances.
* @ingroup ContHelpers
* The C++ type is always a Glib::RefPtr<>.
*/
template <class T>
-struct TypeTraits< Glib::RefPtr<T> >
+struct TypeTraits<Glib::RefPtr<T>>
{
- typedef Glib::RefPtr<T> CppType;
- typedef typename T::BaseObjectType * CType;
- typedef typename T::BaseObjectType * CTypeNonConst;
+ typedef Glib::RefPtr<T> CppType;
+ typedef typename T::BaseObjectType* CType;
+ typedef typename T::BaseObjectType* CTypeNonConst;
- static CType to_c_type (const CppType& ptr) { return Glib::unwrap(ptr); }
- static CType to_c_type (CType ptr) { return ptr; }
- static CppType to_cpp_type (CType ptr)
+ static CType to_c_type(const CppType& ptr) { return Glib::unwrap(ptr); }
+ static CType to_c_type(CType ptr) { return ptr; }
+ static CppType to_cpp_type(CType ptr)
{
- //return Glib::wrap(ptr, true);
+ // return Glib::wrap(ptr, true);
- //We copy/paste the wrap() implementation here,
- //because we can not use a specific Glib::wrap(CType) overload here,
- //because that would be "dependent", and g++ 3.4 does not allow that.
- //The specific Glib::wrap() overloads don't do anything special anyway.
+ // We copy/paste the wrap() implementation here,
+ // because we can not use a specific Glib::wrap(CType) overload here,
+ // because that would be "dependent", and g++ 3.4 does not allow that.
+ // The specific Glib::wrap() overloads don't do anything special anyway.
GObject* cobj = (GObject*)(ptr);
- return Glib::RefPtr<T>( dynamic_cast<T*>(Glib::wrap_auto(cobj, true /* take_copy */)) );
- //We use dynamic_cast<> in case of multiple inheritance.
+ return Glib::RefPtr<T>(dynamic_cast<T*>(Glib::wrap_auto(cobj, true /* take_copy */)));
+ // We use dynamic_cast<> in case of multiple inheritance.
}
- static void release_c_type (CType ptr)
+ static void release_c_type(CType ptr)
{
GLIBMM_DEBUG_UNREFERENCE(nullptr, ptr);
g_object_unref(ptr);
}
};
-//This confuse the SUN Forte compiler, so we ifdef it out:
+// This confuse the SUN Forte compiler, so we ifdef it out:
#ifdef GLIBMM_HAVE_DISAMBIGUOUS_CONST_TEMPLATE_SPECIALIZATIONS
/** Partial specialization for pointers to const GObject instances.
@@ -227,37 +225,38 @@ struct TypeTraits< Glib::RefPtr<T> >
* The C++ type is always a Glib::RefPtr<>.
*/
template <class T>
-struct TypeTraits< Glib::RefPtr<const T> >
+struct TypeTraits<Glib::RefPtr<const T>>
{
- typedef Glib::RefPtr<const T> CppType;
- typedef const typename T::BaseObjectType * CType;
- typedef typename T::BaseObjectType * CTypeNonConst;
+ typedef Glib::RefPtr<const T> CppType;
+ typedef const typename T::BaseObjectType* CType;
+ typedef typename T::BaseObjectType* CTypeNonConst;
- static CType to_c_type (const CppType& ptr) { return Glib::unwrap(ptr); }
- static CType to_c_type (CType ptr) { return ptr; }
- static CppType to_cpp_type (CType ptr)
+ static CType to_c_type(const CppType& ptr) { return Glib::unwrap(ptr); }
+ static CType to_c_type(CType ptr) { return ptr; }
+ static CppType to_cpp_type(CType ptr)
{
- //return Glib::wrap(ptr, true);
+ // return Glib::wrap(ptr, true);
- //We copy/paste the wrap() implementation here,
- //because we can not use a specific Glib::wrap(CType) overload here,
- //because that would be "dependent", and g++ 3.4 does not allow that.
- //The specific Glib::wrap() overloads don't do anything special anyway.
+ // We copy/paste the wrap() implementation here,
+ // because we can not use a specific Glib::wrap(CType) overload here,
+ // because that would be "dependent", and g++ 3.4 does not allow that.
+ // The specific Glib::wrap() overloads don't do anything special anyway.
GObject* cobj = (GObject*)const_cast<CTypeNonConst>(ptr);
- return Glib::RefPtr<const T>( dynamic_cast<const T*>(Glib::wrap_auto(cobj, true /* take_copy */)) );
- //We use dynamic_cast<> in case of multiple inheritance.
+ return Glib::RefPtr<const T>(
+ dynamic_cast<const T*>(Glib::wrap_auto(cobj, true /* take_copy */)));
+ // We use dynamic_cast<> in case of multiple inheritance.
}
- static void release_c_type (CType ptr)
+ static void release_c_type(CType ptr)
{
GLIBMM_DEBUG_UNREFERENCE(nullptr, ptr);
g_object_unref(const_cast<CTypeNonConst>(ptr));
}
};
-#endif //GLIBMM_HAVE_DISAMBIGUOUS_CONST_TEMPLATE_SPECIALIZATIONS
+#endif // GLIBMM_HAVE_DISAMBIGUOUS_CONST_TEMPLATE_SPECIALIZATIONS
-#endif //GLIBMM_CAN_USE_DYNAMIC_CAST_IN_UNUSED_TEMPLATE_WITHOUT_DEFINITION
+#endif // GLIBMM_CAN_USE_DYNAMIC_CAST_IN_UNUSED_TEMPLATE_WITHOUT_DEFINITION
/** Specialization for UTF-8 strings.
* @ingroup ContHelpers
@@ -269,18 +268,16 @@ template <>
struct TypeTraits<Glib::ustring>
{
typedef Glib::ustring CppType;
- typedef const char * CType;
- typedef char * CTypeNonConst;
+ typedef const char* CType;
+ typedef char* CTypeNonConst;
- static CType to_c_type (const Glib::ustring& str) { return str.c_str(); }
- static CType to_c_type (const std::string& str) { return str.c_str(); }
- static CType to_c_type (CType str) { return str; }
+ static CType to_c_type(const Glib::ustring& str) { return str.c_str(); }
+ static CType to_c_type(const std::string& str) { return str.c_str(); }
+ static CType to_c_type(CType str) { return str; }
- static CppType to_cpp_type(CType str)
- { return (str) ? Glib::ustring(str) : Glib::ustring(); }
+ static CppType to_cpp_type(CType str) { return (str) ? Glib::ustring(str) : Glib::ustring(); }
- static void release_c_type(CType str)
- { g_free(const_cast<CTypeNonConst>(str)); }
+ static void release_c_type(CType str) { g_free(const_cast<CTypeNonConst>(str)); }
};
/** Specialization for std::string.
@@ -292,19 +289,17 @@ struct TypeTraits<Glib::ustring>
template <>
struct TypeTraits<std::string>
{
- typedef std::string CppType;
- typedef const char * CType;
- typedef char * CTypeNonConst;
+ typedef std::string CppType;
+ typedef const char* CType;
+ typedef char* CTypeNonConst;
- static CType to_c_type (const std::string& str) { return str.c_str(); }
- static CType to_c_type (const Glib::ustring& str) { return str.c_str(); }
- static CType to_c_type (CType str) { return str; }
+ static CType to_c_type(const std::string& str) { return str.c_str(); }
+ static CType to_c_type(const Glib::ustring& str) { return str.c_str(); }
+ static CType to_c_type(CType str) { return str; }
- static CppType to_cpp_type(CType str)
- { return (str) ? std::string(str) : std::string(); }
+ static CppType to_cpp_type(CType str) { return (str) ? std::string(str) : std::string(); }
- static void release_c_type(CType str)
- { g_free(const_cast<CTypeNonConst>(str)); }
+ static void release_c_type(CType str) { g_free(const_cast<CTypeNonConst>(str)); }
};
/** Specialization for bool.
@@ -313,14 +308,14 @@ struct TypeTraits<std::string>
template <>
struct TypeTraits<bool>
{
- typedef bool CppType;
+ typedef bool CppType;
typedef gboolean CType;
typedef gboolean CTypeNonConst;
- static CType to_c_type (CppType item) { return static_cast<CType>(item); }
- static CType to_c_type (CType item) { return item; }
- static CppType to_cpp_type (CType item) { return (item != 0); }
- static void release_c_type (CType) {}
+ static CType to_c_type(CppType item) { return static_cast<CType>(item); }
+ static CType to_c_type(CType item) { return item; }
+ static CppType to_cpp_type(CType item) { return (item != 0); }
+ static void release_c_type(CType) {}
};
/** Specialization for Glib::VariantBase.
@@ -329,20 +324,17 @@ struct TypeTraits<bool>
template <>
struct TypeTraits<Glib::VariantBase>
{
- typedef Glib::VariantBase CppType;
- typedef GVariant * CType;
- typedef GVariant * CTypeNonConst;
+ typedef Glib::VariantBase CppType;
+ typedef GVariant* CType;
+ typedef GVariant* CTypeNonConst;
- static CType to_c_type (const Glib::VariantBase& v)
- { return const_cast<CTypeNonConst>(v.gobj()); }
+ static CType to_c_type(const Glib::VariantBase& v) { return const_cast<CTypeNonConst>(v.gobj()); }
- static CType to_c_type (CType v) { return v; }
+ static CType to_c_type(CType v) { return v; }
- static CppType to_cpp_type(CType v)
- { return Glib::VariantBase(v, true); }
+ static CppType to_cpp_type(CType v) { return Glib::VariantBase(v, true); }
- static void release_c_type(CType v)
- { g_variant_unref(const_cast<CTypeNonConst>(v)); }
+ static void release_c_type(CType v) { g_variant_unref(const_cast<CTypeNonConst>(v)); }
};
/** Specialization for Glib::VariantContainerBase.
@@ -351,23 +343,22 @@ struct TypeTraits<Glib::VariantBase>
template <>
struct TypeTraits<Glib::VariantContainerBase>
{
- typedef Glib::VariantContainerBase CppType;
- typedef GVariant * CType;
- typedef GVariant * CTypeNonConst;
+ typedef Glib::VariantContainerBase CppType;
+ typedef GVariant* CType;
+ typedef GVariant* CTypeNonConst;
- static CType to_c_type (const Glib::VariantContainerBase& v)
- { return const_cast<CTypeNonConst>(v.gobj()); }
+ static CType to_c_type(const Glib::VariantContainerBase& v)
+ {
+ return const_cast<CTypeNonConst>(v.gobj());
+ }
- static CType to_c_type (CType v) { return v; }
+ static CType to_c_type(CType v) { return v; }
- static CppType to_cpp_type(CType v)
- { return Glib::VariantContainerBase(v, true); }
+ static CppType to_cpp_type(CType v) { return Glib::VariantContainerBase(v, true); }
- static void release_c_type(CType v)
- { g_variant_unref(const_cast<CTypeNonConst>(v)); }
+ static void release_c_type(CType v) { g_variant_unref(const_cast<CTypeNonConst>(v)); }
};
-
#ifndef GLIBMM_HAVE_TEMPLATE_SEQUENCE_CTORS
/* The STL containers in Sun's libCstd don't support templated sequence
@@ -375,9 +366,10 @@ struct TypeTraits<Glib::VariantContainerBase>
* is used in the ContainerHandle -> STL-container conversion workarounds.
*/
template <class Cont, class In>
-void fill_container(Cont& container, In pbegin, In pend)
+void
+fill_container(Cont& container, In pbegin, In pend)
{
- for(; pbegin != pend; ++pbegin)
+ for (; pbegin != pend; ++pbegin)
container.emplace_back(*pbegin);
}
diff --git a/glib/glibmm/containers.h b/glib/glibmm/containers.h
index 7bd4d8a..46b87d0 100644
--- a/glib/glibmm/containers.h
+++ b/glib/glibmm/containers.h
@@ -32,15 +32,17 @@
namespace Glib
{
-template <class T> class List_Iterator;
-template <class T> class List_ConstIterator;
-template <class T> class List_ReverseIterator;
+template <class T>
+class List_Iterator;
+template <class T>
+class List_ConstIterator;
+template <class T>
+class List_ReverseIterator;
// Most of these methods in the non-template classes needs to be moved
// to implementation.
-//Daniel Elstner has ideas about generating these per-widget with m4. murrayc.
-
+// Daniel Elstner has ideas about generating these per-widget with m4. murrayc.
extern GLIBMM_API gpointer glibmm_null_pointer;
@@ -48,12 +50,12 @@ template <class T>
class List_Iterator_Base
{
public:
- typedef T value_type;
+ typedef T value_type;
typedef T* pointer;
typedef T& reference;
-} ;
+};
-///For instance, List_Iterator< Gtk::Widget >
+/// For instance, List_Iterator< Gtk::Widget >
template <class T>
class List_Iterator : public List_Iterator_Base<T>
{
@@ -70,22 +72,16 @@ public:
typedef List_Iterator<T> Self;
- List_Iterator(GList* const& head, GList* node)
- : head_(&head), node_(node)
- {}
+ List_Iterator(GList* const& head, GList* node) : head_(&head), node_(node) {}
- List_Iterator()
- : head_(nullptr), node_(nullptr)
- {}
+ List_Iterator() : head_(nullptr), node_(nullptr) {}
- List_Iterator(const Self& src)
- : head_(src.head_), node_(src.node_)
- {}
+ List_Iterator(const Self& src) : head_(src.head_), node_(src.node_) {}
bool operator==(const Self& src) const { return node_ == src.node_; }
bool operator!=(const Self& src) const { return node_ != src.node_; }
- Self& operator++()
+ Self& operator++()
{
if (!node_)
node_ = g_list_first(*head_);
@@ -101,7 +97,7 @@ public:
return tmp;
}
- Self& operator--()
+ Self& operator--()
{
if (!node_)
node_ = g_list_last(*head_);
@@ -118,15 +114,12 @@ public:
return tmp;
}
- reference operator*() const
- {
- return *(pointer)( node_ ? node_->data : glibmm_null_pointer );
- }
+ reference operator*() const { return *(pointer)(node_ ? node_->data : glibmm_null_pointer); }
pointer operator->() const { return &**this; }
};
-///For instance, SList_Iterator< Gtk::Widget >
+/// For instance, SList_Iterator< Gtk::Widget >
template <class T>
class SList_Iterator : public List_Iterator_Base<T>
{
@@ -141,22 +134,16 @@ public:
GSList* node_;
typedef SList_Iterator<T> Self;
- SList_Iterator(GSList* node)
- : node_(node)
- {}
+ SList_Iterator(GSList* node) : node_(node) {}
- SList_Iterator()
- : node_(nullptr)
- {}
+ SList_Iterator() : node_(nullptr) {}
- SList_Iterator(const Self& src)
- : node_(src.node_)
- {}
+ SList_Iterator(const Self& src) : node_(src.node_) {}
bool operator==(const Self& src) const { return node_ == src.node_; }
bool operator!=(const Self& src) const { return node_ != src.node_; }
- Self& operator++()
+ Self& operator++()
{
node_ = g_slist_next(node_);
return *this;
@@ -171,17 +158,16 @@ public:
reference operator*() const
{
- return reinterpret_cast<T&>( node_ ? node_->data : glibmm_null_pointer );
+ return reinterpret_cast<T&>(node_ ? node_->data : glibmm_null_pointer);
}
pointer operator->() const { return &**this; }
};
-
// This iterator variation returns T_IFace (wrapped from T_Impl)
// For instance, List_Cpp_Iterator<GtkWidget, Gtk::Widget> is
// a little like std::list<Gtk::Widget>::iterator
-template<class T_Impl, class T_IFace>
+template <class T_Impl, class T_IFace>
class List_Cpp_Iterator : public List_Iterator_Base<T_IFace>
{
public:
@@ -200,32 +186,27 @@ public:
bool operator==(const Self& src) const { return node_ == src.node_; }
bool operator!=(const Self& src) const { return node_ != src.node_; }
- List_Cpp_Iterator(GList*& head, GList* node )
- : head_(&head), node_(node )
- {}
+ List_Cpp_Iterator(GList*& head, GList* node) : head_(&head), node_(node) {}
- List_Cpp_Iterator()
- : head_(nullptr), node_(nullptr)
- {}
+ List_Cpp_Iterator() : head_(nullptr), node_(nullptr) {}
- List_Cpp_Iterator(const Self& src)
- : head_(src.head_), node_(src.node_)
- {}
+ List_Cpp_Iterator(const Self& src) : head_(src.head_), node_(src.node_) {}
reference operator*() const
{
if (node_ && node_->data)
{
- //We copy/paste the widget wrap() implementation here,
- //because we can not use a specific Glib::wrap(T_Impl) overload here,
- //because that would be "dependent", and g++ 3.4 does not allow that.
- //The specific Glib::wrap() overloads don't do anything special anyway.
+ // We copy/paste the widget wrap() implementation here,
+ // because we can not use a specific Glib::wrap(T_Impl) overload here,
+ // because that would be "dependent", and g++ 3.4 does not allow that.
+ // The specific Glib::wrap() overloads don't do anything special anyway.
GObject* cobj = static_cast<GObject*>(node_->data);
#ifdef GLIBMM_CAN_USE_DYNAMIC_CAST_IN_UNUSED_TEMPLATE_WITHOUT_DEFINITION
return *dynamic_cast<pointer>(Glib::wrap_auto(cobj, false));
#else
- //We really do need to use dynamic_cast<>, so I expect problems if this code is used. murrayc.
+ // We really do need to use dynamic_cast<>, so I expect problems if this code is used.
+ // murrayc.
return *static_cast<pointer>(Glib::wrap_auto(cobj, false));
#endif
}
@@ -234,12 +215,12 @@ public:
pointer operator->() const { return &**this; }
- Self& operator++()
+ Self& operator++()
{
if (!node_)
node_ = g_list_first(*head_);
else
- node_ = (GList *)g_list_next(node_);
+ node_ = (GList*)g_list_next(node_);
return *this;
}
@@ -251,12 +232,12 @@ public:
return tmp;
}
- Self& operator--()
+ Self& operator--()
{
if (!node_)
node_ = g_list_last(*head_);
else
- node_ = (GList *)g_list_previous(node_);
+ node_ = (GList*)g_list_previous(node_);
return *this;
}
@@ -270,85 +251,104 @@ public:
};
template <class T_Base>
-class List_ReverseIterator: private T_Base
+class List_ReverseIterator : private T_Base
{
public:
typedef typename T_Base::iterator_category iterator_category;
- typedef typename T_Base::size_type size_type;
- typedef typename T_Base::difference_type difference_type;
+ typedef typename T_Base::size_type size_type;
+ typedef typename T_Base::difference_type difference_type;
- typedef typename T_Base::value_type value_type;
- typedef typename T_Base::pointer pointer;
- typedef typename T_Base::reference reference;
+ typedef typename T_Base::value_type value_type;
+ typedef typename T_Base::pointer pointer;
+ typedef typename T_Base::reference reference;
- typedef List_ReverseIterator<T_Base> Self;
+ typedef List_ReverseIterator<T_Base> Self;
bool operator==(const Self& src) const { return T_Base::operator==(src); }
bool operator!=(const Self& src) const { return T_Base::operator!=(src); }
- List_ReverseIterator(GList* const& head, GList* node)
- : T_Base(head, node)
- {}
-
- List_ReverseIterator()
- : T_Base()
- {}
+ List_ReverseIterator(GList* const& head, GList* node) : T_Base(head, node) {}
- List_ReverseIterator(const Self& src)
- : T_Base(src)
- {}
+ List_ReverseIterator() : T_Base() {}
- List_ReverseIterator(const T_Base& src)
- : T_Base(src)
- { ++(*this); }
+ List_ReverseIterator(const Self& src) : T_Base(src) {}
+ List_ReverseIterator(const T_Base& src) : T_Base(src) { ++(*this); }
- Self& operator++() {T_Base::operator--(); return *this;}
- Self& operator--() {T_Base::operator++(); return *this;}
- Self operator++(int) {Self src = *this; T_Base::operator--(); return src;}
- Self operator--(int) {Self src = *this; T_Base::operator++(); return src;}
+ Self& operator++()
+ {
+ T_Base::operator--();
+ return *this;
+ }
+ Self& operator--()
+ {
+ T_Base::operator++();
+ return *this;
+ }
+ Self operator++(int)
+ {
+ Self src = *this;
+ T_Base::operator--();
+ return src;
+ }
+ Self operator--(int)
+ {
+ Self src = *this;
+ T_Base::operator++();
+ return src;
+ }
reference operator*() const { return T_Base::operator*(); }
- pointer operator->() const { return T_Base::operator->(); }
+ pointer operator->() const { return T_Base::operator->(); }
};
template <class T_Base>
-class List_ConstIterator: public T_Base
+class List_ConstIterator : public T_Base
{
public:
typedef typename T_Base::iterator_category iterator_category;
- typedef typename T_Base::size_type size_type;
- typedef typename T_Base::difference_type difference_type;
+ typedef typename T_Base::size_type size_type;
+ typedef typename T_Base::difference_type difference_type;
- typedef const typename T_Base::value_type value_type;
- typedef const typename T_Base::pointer pointer;
- typedef const typename T_Base::reference reference;
+ typedef const typename T_Base::value_type value_type;
+ typedef const typename T_Base::pointer pointer;
+ typedef const typename T_Base::reference reference;
typedef List_ConstIterator<T_Base> Self;
bool operator==(const Self& src) const { return T_Base::operator==(src); }
bool operator!=(const Self& src) const { return T_Base::operator!=(src); }
- List_ConstIterator(GList* const& head, GList* node)
- : T_Base(head, node)
- {}
+ List_ConstIterator(GList* const& head, GList* node) : T_Base(head, node) {}
- List_ConstIterator()
- : T_Base()
- {}
+ List_ConstIterator() : T_Base() {}
- List_ConstIterator(const Self& src)
- : T_Base(src)
- {}
+ List_ConstIterator(const Self& src) : T_Base(src) {}
- List_ConstIterator(const T_Base& src)
- : T_Base(src)
- {}
+ List_ConstIterator(const T_Base& src) : T_Base(src) {}
- Self& operator++() {T_Base::operator++(); return *this;}
- Self& operator--() {T_Base::operator--(); return *this;}
- Self operator++(int) {Self src = *this; T_Base::operator++(); return src;}
- Self operator--(int) {Self src = *this; T_Base::operator--(); return src;}
+ Self& operator++()
+ {
+ T_Base::operator++();
+ return *this;
+ }
+ Self& operator--()
+ {
+ T_Base::operator--();
+ return *this;
+ }
+ Self operator++(int)
+ {
+ Self src = *this;
+ T_Base::operator++();
+ return src;
+ }
+ Self operator--(int)
+ {
+ Self src = *this;
+ T_Base::operator--();
+ return src;
+ }
reference operator*() const { return T_Base::operator*(); }
pointer operator->() const { return T_Base::operator->(); }
diff --git a/glib/glibmm/debug.h b/glib/glibmm/debug.h
index 601beb3..831f246 100644
--- a/glib/glibmm/debug.h
+++ b/glib/glibmm/debug.h
@@ -36,46 +36,41 @@
#define GLIBMM_GNUC_PRETTY_FUNCTION ""
#endif
-#define GLIBMM_DEBUG_REFERENCE(cppInstance, cInstance) \
- G_STMT_START{ \
- void *const cppInstance__ = (void*) (cppInstance); \
- void *const cInstance__ = (void*) (cInstance); \
- g_log(G_LOG_DOMAIN, \
- G_LOG_LEVEL_DEBUG, \
- "file %s: line %d (%s):\n" \
- "ref: C++ instance: %p; C instance: %p, ref_count = %u, type = %s\n", \
- __FILE__, \
- __LINE__, \
- GLIBMM_GNUC_PRETTY_FUNCTION, \
- cppInstance__, \
- cInstance__, \
- G_OBJECT(cInstance__)->ref_count, \
- G_OBJECT_TYPE_NAME(cInstance__)); \
- }G_STMT_END
+#define GLIBMM_DEBUG_REFERENCE(cppInstance, cInstance) \
+ G_STMT_START \
+ { \
+ void* const cppInstance__ = (void*)(cppInstance); \
+ void* const cInstance__ = (void*)(cInstance); \
+ g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, \
+ "file %s: line %d (%s):\n" \
+ "ref: C++ instance: %p; C instance: %p, ref_count = %u, type = %s\n", \
+ __FILE__, __LINE__, GLIBMM_GNUC_PRETTY_FUNCTION, cppInstance__, cInstance__, \
+ G_OBJECT(cInstance__)->ref_count, G_OBJECT_TYPE_NAME(cInstance__)); \
+ } \
+ G_STMT_END
-#define GLIBMM_DEBUG_UNREFERENCE(cppInstance, cInstance) \
- G_STMT_START{ \
- void *const cppInstance__ = (void*) (cppInstance); \
- void *const cInstance__ = (void*) (cInstance); \
- g_log(G_LOG_DOMAIN, \
- G_LOG_LEVEL_DEBUG, \
- "file %s: line %d (%s):\n" \
- "unref: C++ instance: %p; C instance: %p, ref_count = %u, type = %s\n", \
- __FILE__, \
- __LINE__, \
- GLIBMM_GNUC_PRETTY_FUNCTION, \
- cppInstance__, \
- cInstance__, \
- G_OBJECT(cInstance__)->ref_count, \
- G_OBJECT_TYPE_NAME(cInstance__)); \
- }G_STMT_END
+#define GLIBMM_DEBUG_UNREFERENCE(cppInstance, cInstance) \
+ G_STMT_START \
+ { \
+ void* const cppInstance__ = (void*)(cppInstance); \
+ void* const cInstance__ = (void*)(cInstance); \
+ g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, \
+ "file %s: line %d (%s):\n" \
+ "unref: C++ instance: %p; C instance: %p, ref_count = %u, type = %s\n", \
+ __FILE__, __LINE__, GLIBMM_GNUC_PRETTY_FUNCTION, cppInstance__, cInstance__, \
+ G_OBJECT(cInstance__)->ref_count, G_OBJECT_TYPE_NAME(cInstance__)); \
+ } \
+ G_STMT_END
#else
-#define GLIBMM_DEBUG_REFERENCE(cppInstance,cInstance) G_STMT_START{ (void)0; }G_STMT_END
-#define GLIBMM_DEBUG_UNREFERENCE(cppInstance,cInstance) G_STMT_START{ (void)0; }G_STMT_END
+#define GLIBMM_DEBUG_REFERENCE(cppInstance, cInstance) \
+ G_STMT_START { (void)0; } \
+ G_STMT_END
+#define GLIBMM_DEBUG_UNREFERENCE(cppInstance, cInstance) \
+ G_STMT_START { (void)0; } \
+ G_STMT_END
#endif /* GLIBMM_DEBUG_REFCOUNTING */
#endif /* _GLIBMM_DEBUG_H */
-
diff --git a/glib/glibmm/dispatcher.h b/glib/glibmm/dispatcher.h
index f5dfa56..e3b0d18 100644
--- a/glib/glibmm/dispatcher.h
+++ b/glib/glibmm/dispatcher.h
@@ -95,7 +95,7 @@ public:
private:
sigc::signal<void> signal_;
- DispatchNotifier* notifier_;
+ DispatchNotifier* notifier_;
#ifndef DOXYGEN_SHOULD_SKIP_THIS
friend class Glib::DispatchNotifier;
diff --git a/glib/glibmm/error.h b/glib/glibmm/error.h
index ab0317b..941dc9d 100644
--- a/glib/glibmm/error.h
+++ b/glib/glibmm/error.h
@@ -23,8 +23,6 @@
#include <glibmm/exception.h>
#include <glib.h>
-
-
namespace Glib
{
@@ -53,7 +51,7 @@ public:
void propagate(GError** dest);
- typedef void (* ThrowFunc) (GError*);
+ typedef void (*ThrowFunc)(GError*);
static void register_init();
static void register_cleanup();
@@ -69,6 +67,4 @@ protected:
} // namespace Glib
-
#endif /* _GLIBMM_ERROR_H */
-
diff --git a/glib/glibmm/exception.h b/glib/glibmm/exception.h
index c0e1270..bc9feae 100644
--- a/glib/glibmm/exception.h
+++ b/glib/glibmm/exception.h
@@ -24,7 +24,6 @@
#include <glibmm/ustring.h>
-
namespace Glib
{
@@ -37,6 +36,4 @@ public:
} // namespace Glib
-
#endif /* _GLIBMM_EXCEPTION_H */
-
diff --git a/glib/glibmm/exceptionhandler.h b/glib/glibmm/exceptionhandler.h
index 350cd02..89c169b 100644
--- a/glib/glibmm/exceptionhandler.h
+++ b/glib/glibmm/exceptionhandler.h
@@ -24,7 +24,6 @@
#include <glibmmconfig.h>
#include <sigc++/sigc++.h>
-
namespace Glib
{
@@ -35,9 +34,8 @@ sigc::connection add_exception_handler(const sigc::slot<void>& slot);
#ifndef DOXYGEN_SHOULD_SKIP_THIS
// internal
void exception_handlers_invoke() noexcept;
-#endif //DOXYGEN_SHOULD_SKIP_THIS
+#endif // DOXYGEN_SHOULD_SKIP_THIS
} // namespace Glib
#endif /* _GLIBMM_EXCEPTIONHANDLER_H */
-
diff --git a/glib/glibmm/helperlist.h b/glib/glibmm/helperlist.h
index 3000a8c..41f1074 100644
--- a/glib/glibmm/helperlist.h
+++ b/glib/glibmm/helperlist.h
@@ -20,10 +20,10 @@
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-//This is not hidden by GLIBMM_DISABLE_DEPRECATED
-//because gtkmm-2.24 still uses this type in its public API.
-//Note that gtkmm-2.24 itself is completely deprecated, so we really
-//can remove this whole class some time soon.
+// This is not hidden by GLIBMM_DISABLE_DEPRECATED
+// because gtkmm-2.24 still uses this type in its public API.
+// Note that gtkmm-2.24 itself is completely deprecated, so we really
+// can remove this whole class some time soon.
//#ifndef GLIBMM_DISABLE_DEPRECATED
#include <glibmm/containers.h>
@@ -37,20 +37,19 @@ namespace Glib
* @deprecated This class should no longer be necessary. It has not been used
* by glibmm or gtkmm since gtkmm-2.4.
*/
-template< typename T_Child, typename T_CppElement, typename T_Iterator >
+template <typename T_Child, typename T_CppElement, typename T_Iterator>
class HelperList
{
public:
- HelperList()
- : gparent_(nullptr)
- {}
+ HelperList() : gparent_(nullptr) {}
- HelperList(GObject* gp) //We use gp instead of gparent because that can cause warnings about a shadowed
member.
- : gparent_(gp)
- {}
+ HelperList(GObject*
+ gp) // We use gp instead of gparent because that can cause warnings about a shadowed member.
+ : gparent_(gp)
+ {
+ }
- virtual ~HelperList() noexcept
- {}
+ virtual ~HelperList() noexcept {}
typedef T_Child value_type;
typedef value_type& reference;
@@ -63,115 +62,91 @@ public:
typedef T_CppElement element_type;
- typedef std::size_t difference_type; //TODO Why not std::ptrdiff_t?
+ typedef std::size_t difference_type; // TODO Why not std::ptrdiff_t?
typedef std::size_t size_type;
- //These are implemented differently for each Helper List.
+ // These are implemented differently for each Helper List.
virtual iterator erase(iterator) = 0;
virtual void erase(iterator start, iterator stop)
{
- while(start != stop)
- start = erase(start); //Implemented in derived class.
+ while (start != stop)
+ start = erase(start); // Implemented in derived class.
}
virtual void remove(const_reference) = 0;
- size_type size() const
- {
- return g_list_length(glist());
- }
+ size_type size() const { return g_list_length(glist()); }
inline size_type max_size() { return size_type(-1); }
inline bool empty() { return glist() == nullptr; }
- inline iterator begin()
- {return begin_();}
- inline iterator end()
- {return end_();}
+ inline iterator begin() { return begin_(); }
+ inline iterator end() { return end_(); }
- inline const_iterator begin() const
- { return const_iterator(begin_()); }
- inline const_iterator end() const
- { return const_iterator(end_()); }
+ inline const_iterator begin() const { return const_iterator(begin_()); }
+ inline const_iterator end() const { return const_iterator(end_()); }
- inline reverse_iterator rbegin()
- { return reverse_iterator(end_()); }
- inline reverse_iterator rend()
- { return reverse_iterator(begin_()); }
+ inline reverse_iterator rbegin() { return reverse_iterator(end_()); }
+ inline reverse_iterator rend() { return reverse_iterator(begin_()); }
inline const_reverse_iterator rbegin() const
- { return const_reverse_iterator(reverse_iterator(end_())); }
- inline const_reverse_iterator rend() const
- { return const_reverse_iterator(reverse_iterator(begin_())); }
-
- reference front() const
{
- return *begin();
+ return const_reverse_iterator(reverse_iterator(end_()));
}
-
- reference back() const
+ inline const_reverse_iterator rend() const
{
- return *(--end());
+ return const_reverse_iterator(reverse_iterator(begin_()));
}
+ reference front() const { return *begin(); }
+
+ reference back() const { return *(--end()); }
+
reference operator[](size_type l) const
{
size_type j = 0;
iterator i;
- for(i = begin(), j = 0; i != end() && j < l; ++i, ++j)
+ for (i = begin(), j = 0; i != end() && j < l; ++i, ++j)
;
return (*i);
}
-// iterator find(const_reference w)
-// {
-// iterator i = begin();
-// for(i = begin(); i != end() && (*i != w); i++);
-// return i;
-// }
-//
-// iterator find(Widget& w)
-// {
-// iterator i;
-// for (i = begin(); i != end() && ((*i)->$1() != &w); i++);
-// return i;
-// }
-
- //Derived classes might choose to reimplement these as public:
- inline void pop_front()
- { erase(begin()); }
- inline void pop_back()
- { erase(--end()); }
-
- void clear()
- { erase(begin(), end()); }
-
- GObject* gparent()
- { return gparent_; };
- const GObject* gparent() const
- { return gparent_; };
+ // iterator find(const_reference w)
+ // {
+ // iterator i = begin();
+ // for(i = begin(); i != end() && (*i != w); i++);
+ // return i;
+ // }
+ //
+ // iterator find(Widget& w)
+ // {
+ // iterator i;
+ // for (i = begin(); i != end() && ((*i)->$1() != &w); i++);
+ // return i;
+ // }
+
+ // Derived classes might choose to reimplement these as public:
+ inline void pop_front() { erase(begin()); }
+ inline void pop_back() { erase(--end()); }
+
+ void clear() { erase(begin(), end()); }
+
+ GObject* gparent() { return gparent_; };
+ const GObject* gparent() const { return gparent_; };
protected:
- virtual GList*& glist() const = 0; // front of list
+ virtual GList*& glist() const = 0; // front of list
- iterator begin_() const
- {
- return iterator(glist(), glist());
- }
+ iterator begin_() const { return iterator(glist(), glist()); }
- iterator end_() const
- {
- return iterator(glist(), (GList*)nullptr);
- }
+ iterator end_() const { return iterator(glist(), (GList*)nullptr); }
GObject* gparent_;
};
-
} /* namespace Glib */
//#endif //GLIBMM_DISABLE_DEPRECATED
#endif /* _GLIBMM_HELPERLIST_H */
-
diff --git a/glib/glibmm/i18n-lib.h b/glib/glibmm/i18n-lib.h
index a97562a..1a7cd1b 100644
--- a/glib/glibmm/i18n-lib.h
+++ b/glib/glibmm/i18n-lib.h
@@ -27,4 +27,3 @@
#include <glib/gi18n-lib.h>
#endif /* _GLIBMM_I18N_LIB_H */
-
diff --git a/glib/glibmm/i18n.h b/glib/glibmm/i18n.h
index 15158f5..d35d9a7 100644
--- a/glib/glibmm/i18n.h
+++ b/glib/glibmm/i18n.h
@@ -27,4 +27,3 @@
#include <glib/gi18n.h>
#endif /* _GLIBMM_I18N_H */
-
diff --git a/glib/glibmm/init.h b/glib/glibmm/init.h
index 521bdc8..844945a 100644
--- a/glib/glibmm/init.h
+++ b/glib/glibmm/init.h
@@ -33,7 +33,4 @@ void init();
} // namespace Glib
-
-
#endif /* _GLIBMM_INIT_H */
-
diff --git a/glib/glibmm/interface.h b/glib/glibmm/interface.h
index b6bafa7..c737639 100644
--- a/glib/glibmm/interface.h
+++ b/glib/glibmm/interface.h
@@ -23,7 +23,6 @@
#include <glibmm/object.h>
-
namespace Glib
{
@@ -36,9 +35,9 @@ class GLIBMM_API Interface : virtual public Glib::ObjectBase
{
public:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
- typedef Interface CppObjectType;
+ typedef Interface CppObjectType;
typedef Interface_Class CppClassType;
- typedef GTypeInterface BaseClassType;
+ typedef GTypeInterface BaseClassType;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
/** A Default constructor.
@@ -69,17 +68,17 @@ public:
Interface(const Interface&) = delete;
Interface& operator=(const Interface&) = delete;
- //void add_interface(GType gtype_implementer);
+// void add_interface(GType gtype_implementer);
- // Hook for translating API
- //static Glib::Interface* wrap_new(GTypeInterface*);
+// Hook for translating API
+// static Glib::Interface* wrap_new(GTypeInterface*);
#ifndef DOXYGEN_SHOULD_SKIP_THIS
- static GType get_type() G_GNUC_CONST;
+ static GType get_type() G_GNUC_CONST;
static GType get_base_type() G_GNUC_CONST;
#endif
- inline GObject* gobj() { return gobject_; }
+ inline GObject* gobj() { return gobject_; }
inline const GObject* gobj() const { return gobject_; }
};
@@ -88,4 +87,3 @@ RefPtr<ObjectBase> wrap_interface(GObject* object, bool take_copy = false);
} // namespace Glib
#endif /* _GLIBMM_INTERFACE_H */
-
diff --git a/glib/glibmm/listhandle.h b/glib/glibmm/listhandle.h
index b0aa1c8..92f9bec 100644
--- a/glib/glibmm/listhandle.h
+++ b/glib/glibmm/listhandle.h
@@ -34,14 +34,15 @@ namespace Container_Helpers
* This requires bidirectional iterators.
*/
template <class Bi, class Tr>
-GList* create_list(Bi pbegin, Bi pend, Tr)
+GList*
+create_list(Bi pbegin, Bi pend, Tr)
{
GList* head = nullptr;
- while(pend != pbegin)
+ while (pend != pbegin)
{
// Use & to force a warning if the iterator returns a temporary object.
- const void *const item = Tr::to_c_type(*&*--pend);
+ const void* const item = Tr::to_c_type(*&*--pend);
head = g_list_prepend(head, const_cast<void*>(item));
}
@@ -53,14 +54,15 @@ GList* create_list(Bi pbegin, Bi pend, Tr)
* because appending to the list would be horribly inefficient.
*/
template <class For, class Tr>
-GList* create_list(For pbegin, Tr)
+GList*
+create_list(For pbegin, Tr)
{
GList* head = nullptr;
- while(*pbegin)
+ while (*pbegin)
{
// Use & to force a warning if the iterator returns a temporary object.
- const void *const item = Tr::to_c_type(*&*pbegin);
+ const void* const item = Tr::to_c_type(*&*pbegin);
head = g_list_prepend(head, const_cast<void*>(item));
++pbegin;
}
@@ -68,14 +70,15 @@ GList* create_list(For pbegin, Tr)
return g_list_reverse(head);
}
-
/* Convert from any container that supports bidirectional iterators.
*/
template <class Tr, class Cont>
struct ListSourceTraits
{
static GList* get_data(const Cont& cont)
- { return Glib::Container_Helpers::create_list(cont.begin(), cont.end(), Tr()); }
+ {
+ return Glib::Container_Helpers::create_list(cont.begin(), cont.end(), Tr());
+ }
static const Glib::OwnershipType initial_ownership = Glib::OWNERSHIP_SHALLOW;
};
@@ -84,38 +87,43 @@ struct ListSourceTraits
* argument must be a pointer to the first element.
*/
template <class Tr, class Cont>
-struct ListSourceTraits<Tr,Cont*>
+struct ListSourceTraits<Tr, Cont*>
{
static GList* get_data(const Cont* array)
- { return (array) ? Glib::Container_Helpers::create_list(array, Tr()) : nullptr; }
+ {
+ return (array) ? Glib::Container_Helpers::create_list(array, Tr()) : nullptr;
+ }
static const Glib::OwnershipType initial_ownership = Glib::OWNERSHIP_SHALLOW;
};
template <class Tr, class Cont>
-struct ListSourceTraits<Tr,const Cont*> : ListSourceTraits<Tr,Cont*>
-{};
+struct ListSourceTraits<Tr, const Cont*> : ListSourceTraits<Tr, Cont*>
+{
+};
/* Convert from a 0-terminated array. The Cont argument must be a pointer
* to the first element. For consistency, the array must be 0-terminated,
* even though the array size is known at compile time.
*/
template <class Tr, class Cont, std::size_t N>
-struct ListSourceTraits<Tr,Cont[N]>
+struct ListSourceTraits<Tr, Cont[N]>
{
static GList* get_data(const Cont* array)
- { return Glib::Container_Helpers::create_list(array, array + (N - 1), Tr()); }
+ {
+ return Glib::Container_Helpers::create_list(array, array + (N - 1), Tr());
+ }
static const Glib::OwnershipType initial_ownership = Glib::OWNERSHIP_SHALLOW;
};
template <class Tr, class Cont, std::size_t N>
-struct ListSourceTraits<Tr,const Cont[N]> : ListSourceTraits<Tr,Cont[N]>
-{};
+struct ListSourceTraits<Tr, const Cont[N]> : ListSourceTraits<Tr, Cont[N]>
+{
+};
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
/**
* @ingroup ContHelpers
*/
@@ -123,19 +131,19 @@ template <class Tr>
class ListHandleIterator
{
public:
- typedef typename Tr::CppType CppType;
- typedef typename Tr::CType CType;
+ typedef typename Tr::CppType CppType;
+ typedef typename Tr::CType CType;
- typedef std::forward_iterator_tag iterator_category;
- typedef CppType value_type;
- typedef std::ptrdiff_t difference_type;
- typedef value_type reference;
- typedef void pointer;
+ typedef std::forward_iterator_tag iterator_category;
+ typedef CppType value_type;
+ typedef std::ptrdiff_t difference_type;
+ typedef value_type reference;
+ typedef void pointer;
explicit inline ListHandleIterator(const GList* node);
- inline value_type operator*() const;
- inline ListHandleIterator<Tr> & operator++();
+ inline value_type operator*() const;
+ inline ListHandleIterator<Tr>& operator++();
inline const ListHandleIterator<Tr> operator++(int);
inline bool operator==(const ListHandleIterator<Tr>& rhs) const;
@@ -147,7 +155,7 @@ private:
} // namespace Container_Helpers
-//TODO: Remove this when we can break glibmm API.
+// TODO: Remove this when we can break glibmm API.
/** This is an intermediate type. When a method takes this, or returns this, you
* should use a standard C++ container of your choice, such as std::list or
* std::vector.
@@ -157,57 +165,59 @@ private:
*
* @ingroup ContHandles
*/
-template < class T, class Tr = Glib::Container_Helpers::TypeTraits<T> >
+template <class T, class Tr = Glib::Container_Helpers::TypeTraits<T>>
class ListHandle
{
public:
- typedef typename Tr::CppType CppType;
- typedef typename Tr::CType CType;
+ typedef typename Tr::CppType CppType;
+ typedef typename Tr::CType CType;
- typedef CppType value_type;
- typedef std::size_t size_type;
- typedef std::ptrdiff_t difference_type;
+ typedef CppType value_type;
+ typedef std::size_t size_type;
+ typedef std::ptrdiff_t difference_type;
- typedef Glib::Container_Helpers::ListHandleIterator<Tr> const_iterator;
- typedef Glib::Container_Helpers::ListHandleIterator<Tr> iterator;
+ typedef Glib::Container_Helpers::ListHandleIterator<Tr> const_iterator;
+ typedef Glib::Container_Helpers::ListHandleIterator<Tr> iterator;
- template <class Cont> inline
- ListHandle(const Cont& container);
+ template <class Cont>
+ inline ListHandle(const Cont& container);
// Take over ownership of an array created by GTK+ functions.
inline ListHandle(GList* glist, Glib::OwnershipType ownership);
// Copying clears the ownership flag of the source handle.
- inline ListHandle(const ListHandle<T,Tr>& other);
+ inline ListHandle(const ListHandle<T, Tr>& other);
~ListHandle() noexcept;
inline const_iterator begin() const;
- inline const_iterator end() const;
+ inline const_iterator end() const;
- template <class U> inline operator std::vector<U>() const;
- template <class U> inline operator std::deque<U>() const;
- template <class U> inline operator std::list<U>() const;
+ template <class U>
+ inline operator std::vector<U>() const;
+ template <class U>
+ inline operator std::deque<U>() const;
+ template <class U>
+ inline operator std::list<U>() const;
- template <class Cont> inline
- void assign_to(Cont& container) const;
+ template <class Cont>
+ inline void assign_to(Cont& container) const;
- template <class Out> inline
- void copy(Out pdest) const;
+ template <class Out>
+ inline void copy(Out pdest) const;
- inline GList* data() const;
- inline std::size_t size() const;
- inline bool empty() const;
+ inline GList* data() const;
+ inline std::size_t size() const;
+ inline bool empty() const;
private:
- GList * plist_;
+ GList* plist_;
mutable Glib::OwnershipType ownership_;
// No copy assignment.
- ListHandle<T,Tr>& operator=(const ListHandle<T,Tr>&);
+ ListHandle<T, Tr>& operator=(const ListHandle<T, Tr>&);
};
-
/***************************************************************************/
/* Inline implementation */
/***************************************************************************/
@@ -219,106 +229,103 @@ namespace Container_Helpers
/**** Glib::Container_Helpers::ListHandleIterator<> ************************/
-template <class Tr> inline
-ListHandleIterator<Tr>::ListHandleIterator(const GList* node)
-:
- node_ (node)
-{}
+template <class Tr>
+inline ListHandleIterator<Tr>::ListHandleIterator(const GList* node) : node_(node)
+{
+}
-template <class Tr> inline
-typename ListHandleIterator<Tr>::value_type ListHandleIterator<Tr>::operator*() const
+template <class Tr>
+inline typename ListHandleIterator<Tr>::value_type ListHandleIterator<Tr>::operator*() const
{
return Tr::to_cpp_type(static_cast<typename Tr::CTypeNonConst>(node_->data));
}
-template <class Tr> inline
-ListHandleIterator<Tr>& ListHandleIterator<Tr>::operator++()
+template <class Tr>
+inline ListHandleIterator<Tr>& ListHandleIterator<Tr>::operator++()
{
node_ = node_->next;
return *this;
}
-template <class Tr> inline
-const ListHandleIterator<Tr> ListHandleIterator<Tr>::operator++(int)
+template <class Tr>
+inline const ListHandleIterator<Tr> ListHandleIterator<Tr>::operator++(int)
{
- const ListHandleIterator<Tr> tmp (*this);
+ const ListHandleIterator<Tr> tmp(*this);
node_ = node_->next;
return tmp;
}
-template <class Tr> inline
-bool ListHandleIterator<Tr>::operator==(const ListHandleIterator<Tr>& rhs) const
+template <class Tr>
+inline bool
+ListHandleIterator<Tr>::operator==(const ListHandleIterator<Tr>& rhs) const
{
return (node_ == rhs.node_);
}
-template <class Tr> inline
-bool ListHandleIterator<Tr>::operator!=(const ListHandleIterator<Tr>& rhs) const
+template <class Tr>
+inline bool
+ListHandleIterator<Tr>::operator!=(const ListHandleIterator<Tr>& rhs) const
{
return (node_ != rhs.node_);
}
} // namespace Container_Helpers
-
/**** Glib::ListHandle<> ***************************************************/
template <class T, class Tr>
- template <class Cont>
-inline
-ListHandle<T,Tr>::ListHandle(const Cont& container)
-:
- plist_ (Glib::Container_Helpers::ListSourceTraits<Tr,Cont>::get_data(container)),
- ownership_ (Glib::Container_Helpers::ListSourceTraits<Tr,Cont>::initial_ownership)
-{}
-
-template <class T, class Tr> inline
-ListHandle<T,Tr>::ListHandle(GList* glist, Glib::OwnershipType ownership)
-:
- plist_ (glist),
- ownership_ (ownership)
-{}
-
-template <class T, class Tr> inline
-ListHandle<T,Tr>::ListHandle(const ListHandle<T,Tr>& other)
-:
- plist_ (other.plist_),
- ownership_ (other.ownership_)
+template <class Cont>
+inline ListHandle<T, Tr>::ListHandle(const Cont& container)
+: plist_(Glib::Container_Helpers::ListSourceTraits<Tr, Cont>::get_data(container)),
+ ownership_(Glib::Container_Helpers::ListSourceTraits<Tr, Cont>::initial_ownership)
+{
+}
+
+template <class T, class Tr>
+inline ListHandle<T, Tr>::ListHandle(GList* glist, Glib::OwnershipType ownership)
+: plist_(glist), ownership_(ownership)
+{
+}
+
+template <class T, class Tr>
+inline ListHandle<T, Tr>::ListHandle(const ListHandle<T, Tr>& other)
+: plist_(other.plist_), ownership_(other.ownership_)
{
other.ownership_ = Glib::OWNERSHIP_NONE;
}
template <class T, class Tr>
-ListHandle<T,Tr>::~ListHandle() noexcept
+ListHandle<T, Tr>::~ListHandle() noexcept
{
- if(ownership_ != Glib::OWNERSHIP_NONE)
+ if (ownership_ != Glib::OWNERSHIP_NONE)
{
- if(ownership_ != Glib::OWNERSHIP_SHALLOW)
+ if (ownership_ != Glib::OWNERSHIP_SHALLOW)
{
// Deep ownership: release each container element.
- for(GList* node = plist_; node != nullptr; node = node->next)
+ for (GList* node = plist_; node != nullptr; node = node->next)
Tr::release_c_type(static_cast<typename Tr::CTypeNonConst>(node->data));
}
g_list_free(plist_);
}
}
-template <class T, class Tr> inline
-typename ListHandle<T,Tr>::const_iterator ListHandle<T,Tr>::begin() const
+template <class T, class Tr>
+inline typename ListHandle<T, Tr>::const_iterator
+ListHandle<T, Tr>::begin() const
{
return Glib::Container_Helpers::ListHandleIterator<Tr>(plist_);
}
-template <class T, class Tr> inline
-typename ListHandle<T,Tr>::const_iterator ListHandle<T,Tr>::end() const
+template <class T, class Tr>
+inline typename ListHandle<T, Tr>::const_iterator
+ListHandle<T, Tr>::end() const
{
return Glib::Container_Helpers::ListHandleIterator<Tr>(nullptr);
}
template <class T, class Tr>
- template <class U>
-inline
-ListHandle<T,Tr>::operator std::vector<U>() const
+template <class U>
+inline ListHandle<T, Tr>::operator std::vector<U>() const
{
#ifdef GLIBMM_HAVE_TEMPLATE_SEQUENCE_CTORS
return std::vector<U>(this->begin(), this->end());
@@ -331,9 +338,8 @@ ListHandle<T,Tr>::operator std::vector<U>() const
}
template <class T, class Tr>
- template <class U>
-inline
-ListHandle<T,Tr>::operator std::deque<U>() const
+template <class U>
+inline ListHandle<T, Tr>::operator std::deque<U>() const
{
#ifdef GLIBMM_HAVE_TEMPLATE_SEQUENCE_CTORS
return std::deque<U>(this->begin(), this->end());
@@ -345,9 +351,8 @@ ListHandle<T,Tr>::operator std::deque<U>() const
}
template <class T, class Tr>
- template <class U>
-inline
-ListHandle<T,Tr>::operator std::list<U>() const
+template <class U>
+inline ListHandle<T, Tr>::operator std::list<U>() const
{
#ifdef GLIBMM_HAVE_TEMPLATE_SEQUENCE_CTORS
return std::list<U>(this->begin(), this->end());
@@ -359,9 +364,9 @@ ListHandle<T,Tr>::operator std::list<U>() const
}
template <class T, class Tr>
- template <class Cont>
-inline
-void ListHandle<T,Tr>::assign_to(Cont& container) const
+template <class Cont>
+inline void
+ListHandle<T, Tr>::assign_to(Cont& container) const
{
#ifdef GLIBMM_HAVE_TEMPLATE_SEQUENCE_CTORS
container.assign(this->begin(), this->end());
@@ -373,27 +378,30 @@ void ListHandle<T,Tr>::assign_to(Cont& container) const
}
template <class T, class Tr>
- template <class Out>
-inline
-void ListHandle<T,Tr>::copy(Out pdest) const
+template <class Out>
+inline void
+ListHandle<T, Tr>::copy(Out pdest) const
{
std::copy(this->begin(), this->end(), pdest);
}
-template <class T, class Tr> inline
-GList* ListHandle<T,Tr>::data() const
+template <class T, class Tr>
+inline GList*
+ListHandle<T, Tr>::data() const
{
return plist_;
}
-template <class T, class Tr> inline
-std::size_t ListHandle<T,Tr>::size() const
+template <class T, class Tr>
+inline std::size_t
+ListHandle<T, Tr>::size() const
{
return g_list_length(plist_);
}
-template <class T, class Tr> inline
-bool ListHandle<T,Tr>::empty() const
+template <class T, class Tr>
+inline bool
+ListHandle<T, Tr>::empty() const
{
return (plist_ == nullptr);
}
@@ -402,6 +410,4 @@ bool ListHandle<T,Tr>::empty() const
} // namespace Glib
-
#endif /* _GLIBMM_LISTHANDLE_H */
-
diff --git a/glib/glibmm/main.h b/glib/glibmm/main.h
index f92e6f2..5bfacbe 100644
--- a/glib/glibmm/main.h
+++ b/glib/glibmm/main.h
@@ -36,10 +36,10 @@ class Mutex;
namespace Threads
{
- class Cond;
- class Mutex;
+class Cond;
+class Mutex;
}
-#endif //GLIBMM_DISABLE_DEPRECATED
+#endif // GLIBMM_DISABLE_DEPRECATED
/** @defgroup MainLoop The Main Event Loop
* Manages all available sources of events.
@@ -53,16 +53,16 @@ public:
explicit PollFD(int fd);
PollFD(int fd, IOCondition events);
- void set_fd(int fd) { gobject_.fd = fd; }
- int get_fd() const { return gobject_.fd; }
+ void set_fd(int fd) { gobject_.fd = fd; }
+ int get_fd() const { return gobject_.fd; }
- void set_events(IOCondition events) { gobject_.events = events; }
- IOCondition get_events() const { return static_cast<IOCondition>(gobject_.events); }
+ void set_events(IOCondition events) { gobject_.events = events; }
+ IOCondition get_events() const { return static_cast<IOCondition>(gobject_.events); }
void set_revents(IOCondition revents) { gobject_.revents = revents; }
- IOCondition get_revents() const { return static_cast<IOCondition>(gobject_.revents); }
+ IOCondition get_revents() const { return static_cast<IOCondition>(gobject_.revents); }
- GPollFD* gobj() { return &gobject_; }
+ GPollFD* gobj() { return &gobject_; }
const GPollFD* gobj() const { return &gobject_; }
private:
@@ -121,8 +121,8 @@ public:
* @param priority The priority of the new event source.
* @return A connection handle, which can be used to disconnect the handler.
*/
- sigc::connection connect(const sigc::slot<bool>& slot, unsigned int interval,
- int priority = PRIORITY_DEFAULT);
+ sigc::connection connect(
+ const sigc::slot<bool>& slot, unsigned int interval, int priority = PRIORITY_DEFAULT);
/** Connects a timeout handler that runs only once.
* This method takes a function pointer to a function with a void return
@@ -143,8 +143,8 @@ public:
* @param interval The timeout in milliseconds.
* @param priority The priority of the new event source.
*/
- void connect_once(const sigc::slot<void>& slot, unsigned int interval,
- int priority = PRIORITY_DEFAULT);
+ void connect_once(
+ const sigc::slot<void>& slot, unsigned int interval, int priority = PRIORITY_DEFAULT);
/** Connects a timeout handler with whole second granularity.
*
@@ -181,8 +181,8 @@ public:
*
* @newin{2,14}
*/
- sigc::connection connect_seconds(const sigc::slot<bool>& slot, unsigned int interval,
- int priority = PRIORITY_DEFAULT);
+ sigc::connection connect_seconds(
+ const sigc::slot<bool>& slot, unsigned int interval, int priority = PRIORITY_DEFAULT);
/** Connects a timeout handler that runs only once with whole second
* granularity.
@@ -205,8 +205,8 @@ public:
* @param interval The timeout in seconds.
* @param priority The priority of the new event source.
*/
- void connect_seconds_once(const sigc::slot<void>& slot, unsigned int interval,
- int priority = PRIORITY_DEFAULT);
+ void connect_seconds_once(
+ const sigc::slot<void>& slot, unsigned int interval, int priority = PRIORITY_DEFAULT);
private:
GMainContext* context_;
@@ -215,7 +215,6 @@ private:
SignalTimeout& operator=(const SignalTimeout&);
};
-
class SignalIdle
{
public:
@@ -274,7 +273,6 @@ private:
SignalIdle& operator=(const SignalIdle&);
};
-
class SignalIO
{
public:
@@ -307,8 +305,8 @@ public:
* @param priority The priority of the new event source.
* @return A connection handle, which can be used to disconnect the handler.
*/
- sigc::connection connect(const sigc::slot<bool,IOCondition>& slot, int fd,
- IOCondition condition, int priority = PRIORITY_DEFAULT);
+ sigc::connection connect(const sigc::slot<bool, IOCondition>& slot, int fd, IOCondition condition,
+ int priority = PRIORITY_DEFAULT);
/** Connects an I/O handler that watches an I/O channel.
* @code
@@ -327,7 +325,8 @@ public:
* returned sigc::connection object, only from the thread where the SignalIO
* object's MainContext runs.
*
- * @param slot A slot to call when polling @a channel results in an event that matches @a condition.
+ * @param slot A slot to call when polling @a channel results in an event that matches @a
+ * condition.
* The event will be passed as a parameter to @a slot.
* If <tt>io_handler()</tt> returns <tt>false</tt> the handler is disconnected.
* @param channel The IOChannel object to watch.
@@ -335,8 +334,8 @@ public:
* @param priority The priority of the new event source.
* @return A connection handle, which can be used to disconnect the handler.
*/
- sigc::connection connect(const sigc::slot<bool,IOCondition>& slot, const Glib::RefPtr<IOChannel>& channel,
- IOCondition condition, int priority = PRIORITY_DEFAULT);
+ sigc::connection connect(const sigc::slot<bool, IOCondition>& slot,
+ const Glib::RefPtr<IOChannel>& channel, IOCondition condition, int priority = PRIORITY_DEFAULT);
private:
GMainContext* context_;
@@ -366,8 +365,9 @@ public:
* @param priority The priority of the new event source.
* @return A connection handle, which can be used to disconnect the handler.
*/
- sigc::connection connect(const sigc::slot<void,GPid, int>& slot, GPid pid,
-int priority = PRIORITY_DEFAULT);
+ sigc::connection connect(
+ const sigc::slot<void, GPid, int>& slot, GPid pid, int priority = PRIORITY_DEFAULT);
+
private:
GMainContext* context_;
@@ -395,14 +395,13 @@ SignalIO signal_io();
*/
SignalChildWatch signal_child_watch();
-
/** Main context.
*/
class MainContext
{
public:
- typedef Glib::MainContext CppObjectType;
- typedef GMainContext BaseObjectType;
+ typedef Glib::MainContext CppObjectType;
+ typedef GMainContext BaseObjectType;
// noncopyable
MainContext(const MainContext& other) = delete;
@@ -413,16 +412,21 @@ public:
*/
static Glib::RefPtr<MainContext> create();
/** Returns the default main context.
- * This is the main context used for main loop functions when a main loop is not explicitly specified.
+ * This is the main context used for main loop functions when a main loop is not explicitly
+ * specified.
* @return The new MainContext.
*/
static Glib::RefPtr<MainContext> get_default();
/** Runs a single iteration for the given main loop.
- * This involves checking to see if any event sources are ready to be processed, then if no events sources
are
- * ready and may_block is true, waiting for a source to become ready, then dispatching the highest
priority events
- * sources that are ready. Note that even when may_block is true, it is still possible for iteration() to
return
- * false, since the the wait may be interrupted for other reasons than an event source becoming ready.
+ * This involves checking to see if any event sources are ready to be processed, then if no events
+ * sources are
+ * ready and may_block is true, waiting for a source to become ready, then dispatching the highest
+ * priority events
+ * sources that are ready. Note that even when may_block is true, it is still possible for
+ * iteration() to return
+ * false, since the the wait may be interrupted for other reasons than an event source becoming
+ * ready.
* @param may_block Whether the call may block.
* @return true if events were dispatched.
*/
@@ -433,13 +437,16 @@ public:
*/
bool pending();
- /** If context is currently waiting in a poll(), interrupt the poll(), and continue the iteration process.
+ /** If context is currently waiting in a poll(), interrupt the poll(), and continue the iteration
+ * process.
*/
void wakeup();
/** Tries to become the owner of the specified context.
- * If some other thread is the owner of the context, returns <tt>false</tt> immediately. Ownership is
properly recursive:
- * the owner can require ownership again and will release ownership when release() is called as many times
as
+ * If some other thread is the owner of the context, returns <tt>false</tt> immediately. Ownership
+ * is properly recursive:
+ * the owner can require ownership again and will release ownership when release() is called as
+ * many times as
* acquire().
* You must be the owner of a context before you can call prepare(), query(), check(), dispatch().
* @return true if the operation succeeded, and this thread is now the owner of context.
@@ -447,8 +454,10 @@ public:
bool acquire();
#ifndef GLIBMM_DISABLE_DEPRECATED
- /** Tries to become the owner of the specified context, as with acquire(). But if another thread is the
owner,
- * atomically drop mutex and wait on cond until that owner releases ownership or until cond is signaled,
then try
+ /** Tries to become the owner of the specified context, as with acquire(). But if another thread
+ * is the owner,
+ * atomically drop mutex and wait on cond until that owner releases ownership or until cond is
+ * signaled, then try
* again (once) to become the owner.
* @param cond A condition variable.
* @param mutex A mutex, currently held.
@@ -458,32 +467,37 @@ public:
*/
bool wait(Glib::Cond& cond, Glib::Mutex& mutex);
- //Deprecated mostly because it uses deprecated Glib::Threads:: for parameters.
- /** Tries to become the owner of the specified context, as with acquire(). But if another thread is the
owner,
- * atomically drop mutex and wait on cond until that owner releases ownership or until cond is signaled,
then try
+ // Deprecated mostly because it uses deprecated Glib::Threads:: for parameters.
+ /** Tries to become the owner of the specified context, as with acquire(). But if another thread
+ * is the owner,
+ * atomically drop mutex and wait on cond until that owner releases ownership or until cond is
+ * signaled, then try
* again (once) to become the owner.
* @param cond A condition variable.
* @param mutex A mutex, currently held.
* @return true if the operation succeeded, and this thread is now the owner of context.
*
- * @deprecated Please use the underlying g_main_context_wait() function if you really need this
functionality.
+ * @deprecated Please use the underlying g_main_context_wait() function if you really need this
+ * functionality.
*/
bool wait(Glib::Threads::Cond& cond, Glib::Threads::Mutex& mutex);
-#endif //GLIBMM_DISABLE_DEPRECATED
+#endif // GLIBMM_DISABLE_DEPRECATED
- /** Releases ownership of a context previously acquired by this thread with acquire(). If the context was
acquired
- * multiple times, the only release ownership when release() is called as many times as it was acquired.
+ /** Releases ownership of a context previously acquired by this thread with acquire(). If the
+ * context was acquired
+ * multiple times, the only release ownership when release() is called as many times as it was
+ * acquired.
*/
void release();
-
-
- /** Prepares to poll sources within a main loop. The resulting information for polling is determined by
calling query().
+ /** Prepares to poll sources within a main loop. The resulting information for polling is
+ * determined by calling query().
* @param priority Location to store priority of highest priority source already ready.
* @return true if some source is ready to be dispatched prior to polling.
*/
bool prepare(int& priority);
- /** Prepares to poll sources within a main loop. The resulting information for polling is determined by
calling query().
+ /** Prepares to poll sources within a main loop. The resulting information for polling is
+ * determined by calling query().
* @return true if some source is ready to be dispatched prior to polling.
*/
bool prepare();
@@ -492,7 +506,8 @@ public:
* @param max_priority Maximum priority source to check.
* @param timeout Location to store timeout to be used in polling.
* @param fds Location to store Glib::PollFD records that need to be polled.
- * @return the number of records actually stored in fds, or, if more than n_fds records need to be stored,
the number of records that need to be stored.
+ * @return the number of records actually stored in fds, or, if more than n_fds records need to be
+ * stored, the number of records that need to be stored.
*/
void query(int max_priority, int& timeout, std::vector<PollFD>& fds);
@@ -507,9 +522,12 @@ public:
*/
void dispatch();
- //TODO: Use slot instead?
- /** Sets the function to use to handle polling of file descriptors. It will be used instead of the poll()
system call (or GLib's replacement function, which is used where poll() isn't available).
- * This function could possibly be used to integrate the GLib event loop with an external event loop.
+ // TODO: Use slot instead?
+ /** Sets the function to use to handle polling of file descriptors. It will be used instead of the
+ * poll() system call (or GLib's replacement function, which is used where poll() isn't
+ * available).
+ * This function could possibly be used to integrate the GLib event loop with an external event
+ * loop.
* @param poll_func The function to call to poll all file descriptors.
*/
void set_poll_func(GPollFunc poll_func);
@@ -519,13 +537,18 @@ public:
*/
GPollFunc get_poll_func();
- /** Adds a file descriptor to the set of file descriptors polled for this context. This will very seldomly
be used directly. Instead a typical event source will use Glib::Source::add_poll() instead.
+ /** Adds a file descriptor to the set of file descriptors polled for this context. This will very
+ * seldomly be used directly. Instead a typical event source will use Glib::Source::add_poll()
+ * instead.
* @param fd A PollFD structure holding information about a file descriptor to watch.
- * @param priority The priority for this file descriptor which should be the same as the priority used for
Glib::Source::attach() to ensure that the file descriptor is polled whenever the results may be needed.
+ * @param priority The priority for this file descriptor which should be the same as the priority
+ * used for Glib::Source::attach() to ensure that the file descriptor is polled whenever the
+ * results may be needed.
*/
void add_poll(PollFD& fd, int priority);
- /** Removes file descriptor from the set of file descriptors to be polled for a particular context.
+ /** Removes file descriptor from the set of file descriptors to be polled for a particular
+ * context.
* @param fd A PollFD structure holding information about a file descriptor.
*/
void remove_poll(PollFD& fd);
@@ -582,12 +605,12 @@ public:
*/
SignalChildWatch signal_child_watch();
- void reference() const;
+ void reference() const;
void unreference() const;
- GMainContext* gobj();
+ GMainContext* gobj();
const GMainContext* gobj() const;
- GMainContext* gobj_copy() const;
+ GMainContext* gobj_copy() const;
private:
// Glib::MainContext can neither be constructed nor deleted.
@@ -598,19 +621,19 @@ private:
/** @relates Glib::MainContext */
Glib::RefPtr<MainContext> wrap(GMainContext* gobject, bool take_copy = false);
-
class MainLoop
{
public:
- typedef Glib::MainLoop CppObjectType;
- typedef GMainLoop BaseObjectType;
+ typedef Glib::MainLoop CppObjectType;
+ typedef GMainLoop BaseObjectType;
static Glib::RefPtr<MainLoop> create(bool is_running = false);
- static Glib::RefPtr<MainLoop> create(const Glib::RefPtr<MainContext>& context,
- bool is_running = false);
+ static Glib::RefPtr<MainLoop> create(
+ const Glib::RefPtr<MainContext>& context, bool is_running = false);
/** Runs a main loop until quit() is called on the loop.
- * If this is called for the thread of the loop's MainContext, it will process events from the loop,
otherwise it will simply wait.
+ * If this is called for the thread of the loop's MainContext, it will process events from the
+ * loop, otherwise it will simply wait.
*/
void run();
@@ -628,21 +651,21 @@ public:
*/
Glib::RefPtr<MainContext> get_context();
- //TODO: C++ize the (big) g_main_depth docs here.
+ // TODO: C++ize the (big) g_main_depth docs here.
static int depth();
/** Increases the reference count on a MainLoop object by one.
*/
- void reference() const;
+ void reference() const;
/** Decreases the reference count on a MainLoop object by one.
* If the result is zero, free the loop and free all associated memory.
*/
void unreference() const;
- GMainLoop* gobj();
+ GMainLoop* gobj();
const GMainLoop* gobj() const;
- GMainLoop* gobj_copy() const;
+ GMainLoop* gobj_copy() const;
private:
// Glib::MainLoop can neither be constructed nor deleted.
@@ -656,12 +679,11 @@ private:
/** @relates Glib::MainLoop */
Glib::RefPtr<MainLoop> wrap(GMainLoop* gobject, bool take_copy = false);
-
class Source
{
public:
- typedef Glib::Source CppObjectType;
- typedef GSource BaseObjectType;
+ typedef Glib::Source CppObjectType;
+ typedef GSource BaseObjectType;
// noncopyable
Source(const Source&) = delete;
@@ -681,14 +703,17 @@ public:
*/
unsigned int attach();
- //TODO: Does this destroy step make sense in C++? Should it just be something that happens in a destructor?
+ // TODO: Does this destroy step make sense in C++? Should it just be something that happens in a
+ // destructor?
/** Removes a source from its MainContext, if any, and marks it as destroyed.
* The source cannot be subsequently added to another context.
*/
void destroy();
- /** Sets the priority of a source. While the main loop is being run, a source will be dispatched if it is
ready to be dispatched and no sources at a higher (numerically smaller) priority are ready to be dispatched.
+ /** Sets the priority of a source. While the main loop is being run, a source will be dispatched
+ * if it is ready to be dispatched and no sources at a higher (numerically smaller) priority are
+ * ready to be dispatched.
* @param priority The new priority.
*/
void set_priority(int priority);
@@ -696,10 +721,12 @@ public:
/** Gets the priority of a source.
* @return The priority of the source.
*/
- int get_priority() const;
+ int get_priority() const;
/** Sets whether a source can be called recursively.
- * If @a can_recurse is true, then while the source is being dispatched then this source will be processed
normally. Otherwise, all processing of this source is blocked until the dispatch function returns.
+ * If @a can_recurse is true, then while the source is being dispatched then this source will be
+ * processed normally. Otherwise, all processing of this source is blocked until the dispatch
+ * function returns.
* @param can_recurse Whether recursion is allowed for this source.
*/
void set_can_recurse(bool can_recurse);
@@ -710,23 +737,25 @@ public:
bool get_can_recurse() const;
/** Returns the numeric ID for a particular source.
- * The ID of a source is unique within a particular main loop context. The reverse mapping from ID to
source is done by MainContext::find_source_by_id().
+ * The ID of a source is unique within a particular main loop context. The reverse mapping from ID
+ * to source is done by MainContext::find_source_by_id().
* @return The ID for the source.
*/
unsigned int get_id() const;
- //TODO: Add a const version of this method?
+ // TODO: Add a const version of this method?
/** Gets the MainContext with which the source is associated.
* Calling this function on a destroyed source is an error.
- * @return The MainContext with which the source is associated, or a null RefPtr if the context has not
yet been added to a source.
+ * @return The MainContext with which the source is associated, or a null RefPtr if the context
+ * has not yet been added to a source.
*/
Glib::RefPtr<MainContext> get_context();
- GSource* gobj() { return gobject_; }
+ GSource* gobj() { return gobject_; }
const GSource* gobj() const { return gobject_; }
- GSource* gobj_copy() const;
+ GSource* gobj_copy() const;
- void reference() const;
+ void reference() const;
void unreference() const;
protected:
@@ -748,7 +777,8 @@ protected:
sigc::connection connect_generic(const sigc::slot_base& slot);
/** Adds a file descriptor to the set of file descriptors polled for this source.
- * The event source's check function will typically test the revents field in the PollFD and return true
if events need to be processed.
+ * The event source's check function will typically test the revents field in the PollFD and
+ * return true if events need to be processed.
* @param poll_fd A PollFD object holding information about a file descriptor to watch.
*/
void add_poll(PollFD& poll_fd);
@@ -759,15 +789,17 @@ protected:
void remove_poll(PollFD& poll_fd);
#ifndef GLIBMM_DISABLE_DEPRECATED
- /** Gets the "current time" to be used when checking this source. The advantage of calling this function
over calling get_current_time() directly is that when checking multiple sources, GLib can cache a single
value instead of having to repeatedly get the system time.
+ /** Gets the "current time" to be used when checking this source. The advantage of calling this
+ * function over calling get_current_time() directly is that when checking multiple sources, GLib
+ * can cache a single value instead of having to repeatedly get the system time.
* @param current_time Glib::TimeVal in which to store current time.
*
* @deprecated Use get_time() instead.
*/
void get_current_time(Glib::TimeVal& current_time);
-#endif //GLIBMM_DISABLE_DEPRECATED
+#endif // GLIBMM_DISABLE_DEPRECATED
- //TODO: Remove mention of g_get_monotonic time when we wrap it in C++.
+ // TODO: Remove mention of g_get_monotonic time when we wrap it in C++.
/** Gets the time to be used when checking this source. The advantage of
* calling this function over calling g_get_monotonic_time() directly is
* that when checking multiple sources, GLib can cache a single value
@@ -810,7 +842,6 @@ public:
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
};
-
class TimeoutSource : public Glib::Source
{
public:
@@ -828,13 +859,12 @@ protected:
bool dispatch(sigc::slot_base* slot) override;
private:
- //TODO: Replace with gint64, because TimeVal is deprecated, when we can break ABI.
+ // TODO: Replace with gint64, because TimeVal is deprecated, when we can break ABI.
Glib::TimeVal expiration_;
- unsigned int interval_;
+ unsigned int interval_;
};
-
class IdleSource : public Glib::Source
{
public:
@@ -852,15 +882,15 @@ protected:
bool dispatch(sigc::slot_base* slot_data) override;
};
-
class IOSource : public Glib::Source
{
public:
typedef Glib::IOSource CppObjectType;
static Glib::RefPtr<IOSource> create(int fd, IOCondition condition);
- static Glib::RefPtr<IOSource> create(const Glib::RefPtr<IOChannel>& channel, IOCondition condition);
- sigc::connection connect(const sigc::slot<bool,IOCondition>& slot);
+ static Glib::RefPtr<IOSource> create(
+ const Glib::RefPtr<IOChannel>& channel, IOCondition condition);
+ sigc::connection connect(const sigc::slot<bool, IOCondition>& slot);
protected:
IOSource(int fd, IOCondition condition);
@@ -887,5 +917,4 @@ private:
} // namespace Glib
-
#endif /* _GLIBMM_MAIN_H */
diff --git a/glib/glibmm/object.h b/glib/glibmm/object.h
index 566780b..1ec9f3b 100644
--- a/glib/glibmm/object.h
+++ b/glib/glibmm/object.h
@@ -18,10 +18,12 @@
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-//X11 defines DestroyNotify and some other non-prefixed stuff, and it's too late to change that now,
-//so let's give people a clue about the compilation errors that they will see:
+// X11 defines DestroyNotify and some other non-prefixed stuff, and it's too late to change that
+// now,
+// so let's give people a clue about the compilation errors that they will see:
#ifdef DestroyNotify
-# error "X11/Xlib.h seems to have been included before this header. Due to some commonly-named macros in
X11/Xlib.h, it may only be included after any glibmm, gdkmm, or gtkmm headers."
+#error \
+ "X11/Xlib.h seems to have been included before this header. Due to some commonly-named macros in
X11/Xlib.h, it may only be included after any glibmm, gdkmm, or gtkmm headers."
#endif
#include <glibmmconfig.h>
@@ -29,20 +31,18 @@
#include <glibmm/wrap.h>
#include <glibmm/quark.h>
#include <glibmm/refptr.h>
-#include <glibmm/utility.h> /* Could be private, but that would be tedious. */
+#include <glibmm/utility.h> /* Could be private, but that would be tedious. */
#include <glibmm/containerhandle_shared.h> /* Because its specializations may be here. */
#include <glibmm/value.h>
#include <glib.h> /* for G_GNUC_NULL_TERMINATED */
#ifndef DOXYGEN_SHOULD_SKIP_THIS
-extern "C"
-{
+extern "C" {
typedef struct _GObject GObject;
typedef struct _GObjectClass GObjectClass;
}
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
namespace Glib
{
@@ -69,13 +69,13 @@ class GSigConnectionNode;
class ConstructParams
{
public:
- const Glib::Class& glibmm_class;
- unsigned int n_parameters;
- GParameter* parameters;
+ const Glib::Class& glibmm_class;
+ unsigned int n_parameters;
+ GParameter* parameters;
explicit ConstructParams(const Glib::Class& glibmm_class_);
- ConstructParams(const Glib::Class& glibmm_class_, const char* first_property_name, ...)
- G_GNUC_NULL_TERMINATED; // warn if called without a trailing NULL pointer
+ ConstructParams(const Glib::Class& glibmm_class_, const char* first_property_name,
+ ...) G_GNUC_NULL_TERMINATED; // warn if called without a trailing NULL pointer
~ConstructParams() noexcept;
// The copy constructor is semantically required by the C++ compiler
@@ -91,14 +91,13 @@ private:
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
class GLIBMM_API Object : virtual public ObjectBase
{
public:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
- typedef Object CppObjectType;
+ typedef Object CppObjectType;
typedef Object_Class CppClassType;
- typedef GObject BaseObjectType;
+ typedef GObject BaseObjectType;
typedef GObjectClass BaseClassType;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
@@ -110,40 +109,40 @@ public:
Object& operator=(Object&& src) noexcept;
protected:
- Object(); //For use by C++-only sub-types.
+ Object(); // For use by C++-only sub-types.
explicit Object(const Glib::ConstructParams& construct_params);
explicit Object(GObject* castitem);
- ~Object() noexcept override; //It should only be deleted by the callback.
+ ~Object() noexcept override; // It should only be deleted by the callback.
public:
- //static RefPtr<Object> create(); //You must reimplement this in each derived class.
+// static RefPtr<Object> create(); //You must reimplement this in each derived class.
#ifndef DOXYGEN_SHOULD_SKIP_THIS
- static GType get_type() G_GNUC_CONST;
+ static GType get_type() G_GNUC_CONST;
static GType get_base_type() G_GNUC_CONST;
#endif
- //GObject* gobj_copy(); //Give a ref-ed copy to someone. Use for direct struct access.
+ // GObject* gobj_copy(); //Give a ref-ed copy to someone. Use for direct struct access.
// Glib::Objects contain a list<Quark, pair<void*, DestroyNotify> >
// to store run time data added to the object at run time.
- //TODO: Use slots instead:
- void* get_data(const QueryQuark &key);
- void set_data(const Quark &key, void* data);
- typedef void (*DestroyNotify) (gpointer data);
- void set_data(const Quark &key, void* data, DestroyNotify notify);
+ // TODO: Use slots instead:
+ void* get_data(const QueryQuark& key);
+ void set_data(const Quark& key, void* data);
+ typedef void (*DestroyNotify)(gpointer data);
+ void set_data(const Quark& key, void* data, DestroyNotify notify);
void remove_data(const QueryQuark& quark);
// same as remove without notifying
void* steal_data(const QueryQuark& quark);
- // convenience functions
- //template <class T>
- //void set_data_typed(const Quark& quark, const T& data)
- // { set_data(quark, new T(data), delete_typed<T>); }
+// convenience functions
+// template <class T>
+// void set_data_typed(const Quark& quark, const T& data)
+// { set_data(quark, new T(data), delete_typed<T>); }
- //template <class T>
- //T& get_data_typed(const QueryQuark& quark)
- // { return *static_cast<T*>(get_data(quark)); }
+// template <class T>
+// T& get_data_typed(const QueryQuark& quark)
+// { return *static_cast<T*>(get_data(quark)); }
#ifndef DOXYGEN_SHOULD_SKIP_THIS
@@ -154,14 +153,13 @@ private:
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
// Glib::Object can not be dynamic because it lacks a float state.
- //virtual void set_manage();
+ // virtual void set_manage();
};
-
-//For some (proably, more spec-compliant) compilers, these specializations must
-//be next to the objects that they use.
+// For some (proably, more spec-compliant) compilers, these specializations must
+// be next to the objects that they use.
#ifndef GLIBMM_CAN_USE_DYNAMIC_CAST_IN_UNUSED_TEMPLATE_WITHOUT_DEFINITION
-# ifndef DOXYGEN_SHOULD_SKIP_THIS /* hide the specializations */
+#ifndef DOXYGEN_SHOULD_SKIP_THIS /* hide the specializations */
namespace Container_Helpers
{
@@ -171,25 +169,25 @@ namespace Container_Helpers
* The C++ type is always a Glib::RefPtr<>.
*/
template <class T>
-struct TypeTraits< Glib::RefPtr<T> >
+struct TypeTraits<Glib::RefPtr<T>>
{
- typedef Glib::RefPtr<T> CppType;
- typedef typename T::BaseObjectType * CType;
- typedef typename T::BaseObjectType * CTypeNonConst;
+ typedef Glib::RefPtr<T> CppType;
+ typedef typename T::BaseObjectType* CType;
+ typedef typename T::BaseObjectType* CTypeNonConst;
- static CType to_c_type (const CppType& ptr) { return Glib::unwrap(ptr); }
- static CType to_c_type (CType ptr) { return ptr; }
- static CppType to_cpp_type(CType ptr)
+ static CType to_c_type(const CppType& ptr) { return Glib::unwrap(ptr); }
+ static CType to_c_type(CType ptr) { return ptr; }
+ static CppType to_cpp_type(CType ptr)
{
- //return Glib::wrap(ptr, true);
+ // return Glib::wrap(ptr, true);
- //We copy/paste the wrap() implementation here,
- //because we can not use a specific Glib::wrap(CType) overload here,
- //because that would be "dependent", and g++ 3.4 does not allow that.
- //The specific Glib::wrap() overloads don't do anything special anyway.
+ // We copy/paste the wrap() implementation here,
+ // because we can not use a specific Glib::wrap(CType) overload here,
+ // because that would be "dependent", and g++ 3.4 does not allow that.
+ // The specific Glib::wrap() overloads don't do anything special anyway.
GObject* cobj = (GObject*)const_cast<CTypeNonConst>(ptr);
- return Glib::RefPtr<T>( dynamic_cast<T*>(Glib::wrap_auto(cobj, true /* take_copy */)) );
- //We use dynamic_cast<> in case of multiple inheritance.
+ return Glib::RefPtr<T>(dynamic_cast<T*>(Glib::wrap_auto(cobj, true /* take_copy */)));
+ // We use dynamic_cast<> in case of multiple inheritance.
}
static void release_c_type(CType ptr)
@@ -199,94 +197,93 @@ struct TypeTraits< Glib::RefPtr<T> >
}
};
-//This confuses the SUN Forte compiler, so we ifdef it out:
-# ifdef GLIBMM_HAVE_DISAMBIGUOUS_CONST_TEMPLATE_SPECIALIZATIONS
+// This confuses the SUN Forte compiler, so we ifdef it out:
+#ifdef GLIBMM_HAVE_DISAMBIGUOUS_CONST_TEMPLATE_SPECIALIZATIONS
/** Partial specialization for pointers to const GObject instances.
* @ingroup ContHelpers
* The C++ type is always a Glib::RefPtr<>.
*/
template <class T>
-struct TypeTraits< Glib::RefPtr<const T> >
+struct TypeTraits<Glib::RefPtr<const T>>
{
- typedef Glib::RefPtr<const T> CppType;
- typedef const typename T::BaseObjectType * CType;
- typedef typename T::BaseObjectType * CTypeNonConst;
+ typedef Glib::RefPtr<const T> CppType;
+ typedef const typename T::BaseObjectType* CType;
+ typedef typename T::BaseObjectType* CTypeNonConst;
- static CType to_c_type (const CppType& ptr) { return Glib::unwrap(ptr); }
- static CType to_c_type (CType ptr) { return ptr; }
- static CppType to_cpp_type(CType ptr)
+ static CType to_c_type(const CppType& ptr) { return Glib::unwrap(ptr); }
+ static CType to_c_type(CType ptr) { return ptr; }
+ static CppType to_cpp_type(CType ptr)
{
- //return Glib::wrap(ptr, true);
+ // return Glib::wrap(ptr, true);
- //We copy/paste the wrap() implementation here,
- //because we can not use a specific Glib::wrap(CType) overload here,
- //because that would be "dependent", and g++ 3.4 does not allow that.
- //The specific Glib::wrap() overloads don't do anything special anyway.
+ // We copy/paste the wrap() implementation here,
+ // because we can not use a specific Glib::wrap(CType) overload here,
+ // because that would be "dependent", and g++ 3.4 does not allow that.
+ // The specific Glib::wrap() overloads don't do anything special anyway.
GObject* cobj = (GObject*)(ptr);
- return Glib::RefPtr<const T>( dynamic_cast<const T*>(Glib::wrap_auto(cobj, true /* take_copy */)) );
- //We use dynamic_cast<> in case of multiple inheritance.
+ return Glib::RefPtr<const T>(
+ dynamic_cast<const T*>(Glib::wrap_auto(cobj, true /* take_copy */)));
+ // We use dynamic_cast<> in case of multiple inheritance.
}
- static void release_c_type (CType ptr)
+ static void release_c_type(CType ptr)
{
GLIBMM_DEBUG_UNREFERENCE(nullptr, ptr);
g_object_unref(const_cast<CTypeNonConst>(ptr));
}
};
-# endif /* GLIBMM_HAVE_DISAMBIGUOUS_CONST_TEMPLATE_SPECIALIZATIONS */
-
-} //namespace Container_Helpers
+#endif /* GLIBMM_HAVE_DISAMBIGUOUS_CONST_TEMPLATE_SPECIALIZATIONS */
+} // namespace Container_Helpers
-template <class T, class PtrT> inline
-PtrT Value_Pointer<T,PtrT>::get_(Glib::Object*) const
+template <class T, class PtrT>
+inline PtrT
+Value_Pointer<T, PtrT>::get_(Glib::Object*) const
{
return dynamic_cast<T*>(get_object());
}
-
/** Partial specialization for RefPtr<> to Glib::Object.
* @ingroup glibmmValue
*/
template <class T>
-class Value< Glib::RefPtr<T> > : public ValueBase_Object
+class Value<Glib::RefPtr<T>> : public ValueBase_Object
{
public:
- typedef Glib::RefPtr<T> CppType;
+ typedef Glib::RefPtr<T> CppType;
typedef typename T::BaseObjectType* CType;
static GType value_type() { return T::get_base_type(); }
void set(const CppType& data) { set_object(data.operator->()); }
- CppType get() const { return Glib::RefPtr<T>::cast_dynamic(get_object_copy()); }
+ CppType get() const { return Glib::RefPtr<T>::cast_dynamic(get_object_copy()); }
};
-//The SUN Forte Compiler has a problem with this:
-# ifdef GLIBMM_HAVE_DISAMBIGUOUS_CONST_TEMPLATE_SPECIALIZATIONS
+// The SUN Forte Compiler has a problem with this:
+#ifdef GLIBMM_HAVE_DISAMBIGUOUS_CONST_TEMPLATE_SPECIALIZATIONS
/** Partial specialization for RefPtr<> to const Glib::Object.
* @ingroup glibmmValue
*/
template <class T>
-class Value< Glib::RefPtr<const T> > : public ValueBase_Object
+class Value<Glib::RefPtr<const T>> : public ValueBase_Object
{
public:
- typedef Glib::RefPtr<const T> CppType;
+ typedef Glib::RefPtr<const T> CppType;
typedef typename T::BaseObjectType* CType;
static GType value_type() { return T::get_base_type(); }
void set(const CppType& data) { set_object(const_cast<T*>(data.operator->())); }
- CppType get() const { return Glib::RefPtr<T>::cast_dynamic(get_object_copy()); }
+ CppType get() const { return Glib::RefPtr<T>::cast_dynamic(get_object_copy()); }
};
-# endif /* GLIBMM_HAVE_DISAMBIGUOUS_CONST_TEMPLATE_SPECIALIZATIONS */
+#endif /* GLIBMM_HAVE_DISAMBIGUOUS_CONST_TEMPLATE_SPECIALIZATIONS */
-# endif /* DOXYGEN_SHOULD_SKIP_THIS */
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
#endif /* GLIBMM_CAN_USE_DYNAMIC_CAST_IN_UNUSED_TEMPLATE_WITHOUT_DEFINITION */
} // namespace Glib
#endif /* _GLIBMM_OBJECT_H */
-
diff --git a/glib/glibmm/objectbase.h b/glib/glibmm/objectbase.h
index f16cfa5..a6b45ac 100644
--- a/glib/glibmm/objectbase.h
+++ b/glib/glibmm/objectbase.h
@@ -28,12 +28,14 @@
#include <glibmm/debug.h>
#include <sigc++/trackable.h>
#include <typeinfo>
-#include <map> // Needed until the next ABI break.
+#include <map> // Needed until the next ABI break.
#include <memory> // Not used by ObjectBase any more, but user code may rely on it being here.
#include <mutex>
#ifndef DOXYGEN_SHOULD_SKIP_THIS
-extern "C" { typedef struct _GObject GObject; }
+extern "C" {
+typedef struct _GObject GObject;
+}
#endif
namespace Glib
@@ -44,8 +46,9 @@ class GSigConnectionNode;
class Interface_Class;
#endif
-//This inherits virtually from sigc::trackable so that people can multiply inherit glibmm classes from other
sigc::trackable-derived classes.
-//See bugzilla.gnome.org bug # 116280
+// This inherits virtually from sigc::trackable so that people can multiply inherit glibmm classes
+// from other sigc::trackable-derived classes.
+// See bugzilla.gnome.org bug # 116280
/** Glib::ObjectBase is a common base class for Objects and Interfaces.
*
* This is used as virtual base class. This means the ObjectBase
@@ -55,7 +58,6 @@ class Interface_Class;
class GLIBMM_API ObjectBase : virtual public sigc::trackable
{
public:
-
// noncopyable
ObjectBase(const ObjectBase&) = delete;
ObjectBase& operator=(const ObjectBase&) = delete;
@@ -104,7 +106,6 @@ protected:
void initialize_move(GObject* castitem, Glib::ObjectBase* previous_wrapper);
public:
-
/// You probably want to use a specific property_*() accessor method instead.
void set_property_value(const Glib::ustring& property_name, const Glib::ValueBase& value);
@@ -119,7 +120,7 @@ public:
template <class PropertyType>
void get_property(const Glib::ustring& property_name, PropertyType& value) const;
- //TODO: At the next ABI break, delete connect_property_changed_with_return()
+ // TODO: At the next ABI break, delete connect_property_changed_with_return()
// and let connect_property_changed() return sigc::connection.
/** You can use the signal_changed() signal of the property proxy instead.
*
@@ -138,13 +139,15 @@ public:
* This method was added because connect_property_changed() does not return a sigc::connection,
* and we could not break the ABI by changing that function.
*/
- sigc::connection connect_property_changed_with_return(const Glib::ustring& property_name, const
sigc::slot<void>& slot);
+ sigc::connection connect_property_changed_with_return(
+ const Glib::ustring& property_name, const sigc::slot<void>& slot);
/** You can use the signal_changed() signal of the property proxy instead.
*
* @newin{2,48}
*/
- sigc::connection connect_property_changed_with_return(const Glib::ustring& property_name,
sigc::slot<void>&& slot);
+ sigc::connection connect_property_changed_with_return(
+ const Glib::ustring& property_name, sigc::slot<void>&& slot);
/** Increases the freeze count on object. If the freeze count is non-zero, the
* emission of "notify" signals on object is stopped. The signals are queued
@@ -177,10 +180,10 @@ public:
*/
virtual void unreference() const;
- ///Provides access to the underlying C GObject.
- inline GObject* gobj() { return gobject_; }
+ /// Provides access to the underlying C GObject.
+ inline GObject* gobj() { return gobject_; }
- ///Provides access to the underlying C GObject.
+ /// Provides access to the underlying C GObject.
inline const GObject* gobj() const { return gobject_; }
/// Give a ref-ed copy to someone. Use for direct struct access.
@@ -189,12 +192,13 @@ public:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
/// This is for use by gtkmm wrappers only, and not by applications.
- static ObjectBase* _get_current_wrapper(GObject* object); //We keep this non-inline version, to preserve
ABI.
+ static ObjectBase* _get_current_wrapper(
+ GObject* object); // We keep this non-inline version, to preserve ABI.
// This is commented-out because it's not clear yet whether it's a worthwhile optimization.
/// This is for use by gtkmm wrappers only, and not by applications.
//
- //inline static ObjectBase* _get_current_wrapper_inline(GObject* object)
+ // inline static ObjectBase* _get_current_wrapper_inline(GObject* object)
//{
// // This is what g_object_get_qdata does internally. However,
// // g_object_get_qdata does an addition G_IS_OBJECT(object) check that
@@ -206,60 +210,58 @@ public:
//}
bool _cpp_destruction_is_in_progress() const;
-#endif //DOXYGEN_SHOULD_SKIP_THIS
+#endif // DOXYGEN_SHOULD_SKIP_THIS
protected:
-
#ifndef DOXYGEN_SHOULD_SKIP_THIS
- GObject* gobject_; // the GLib/GDK/GTK+ object instance
- const char* custom_type_name_;
- bool cpp_destruction_in_progress_;
+ GObject* gobject_; // the GLib/GDK/GTK+ object instance
+ const char* custom_type_name_;
+ bool cpp_destruction_in_progress_;
bool is_anonymous_custom_() const;
-//TODO: At the next ABI break, replace extra_object_base_data by a non-static
-// data member.
-// This is a new data member that can't be added as instance data to
-// ObjectBase now, because it would break ABI.
-struct ExtraObjectBaseData
-{
- Class::interface_class_vector_type custom_interface_classes;
-};
-
-typedef std::map<const ObjectBase*, ExtraObjectBaseData> extra_object_base_data_type;
-static extra_object_base_data_type extra_object_base_data;
-// ObjectBase instances may be used in different threads.
-// Accesses to extra_object_base_data must be thread-safe.
-static std::mutex extra_object_base_data_mutex;
-
-public: // is_derived_() must be public, so that overridden vfuncs and signal handlers can call it via
ObjectBase.
-
+ // TODO: At the next ABI break, replace extra_object_base_data by a non-static
+ // data member.
+ // This is a new data member that can't be added as instance data to
+ // ObjectBase now, because it would break ABI.
+ struct ExtraObjectBaseData
+ {
+ Class::interface_class_vector_type custom_interface_classes;
+ };
+
+ typedef std::map<const ObjectBase*, ExtraObjectBaseData> extra_object_base_data_type;
+ static extra_object_base_data_type extra_object_base_data;
+ // ObjectBase instances may be used in different threads.
+ // Accesses to extra_object_base_data must be thread-safe.
+ static std::mutex extra_object_base_data_mutex;
+
+public: // is_derived_() must be public, so that overridden vfuncs and signal handlers can call it
+ // via ObjectBase.
/// This is for use by gtkmm wrappers only, and not by applications.
- bool is_derived_() const; //We keep this non-inline version, to preserve ABI.
+ bool is_derived_() const; // We keep this non-inline version, to preserve ABI.
- //This is commented-out because it's not clear yet whether it's a worthwhile optimization.
+ // This is commented-out because it's not clear yet whether it's a worthwhile optimization.
//
/// This is for use by gtkmm wrappers only, and not by applications.
- //inline bool is_derived_inline_() const
+ // inline bool is_derived_inline_() const
//{
// return (custom_type_name_ != nullptr);
//}
protected:
- static void destroy_notify_callback_(void* data);
+ static void destroy_notify_callback_(void* data);
virtual void destroy_notify_();
void _set_current_wrapper(GObject* object);
/// For (indirect) use by C++ move operations.
void _move_current_wrapper(GObject* object, Glib::ObjectBase* previous_wrapper) noexcept;
-#endif //DOXYGEN_SHOULD_SKIP_THIS
+#endif // DOXYGEN_SHOULD_SKIP_THIS
private:
-
#ifndef DOXYGEN_SHOULD_SKIP_THIS
virtual void set_manage(); // calls g_error()
-#endif //DOXYGEN_SHOULD_SKIP_THIS
+#endif // DOXYGEN_SHOULD_SKIP_THIS
#ifndef DOXYGEN_SHOULD_SKIP_THIS
friend class Glib::GSigConnectionNode; // for GSigConnectionNode::notify()
@@ -268,8 +270,9 @@ private:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
-template <class PropertyType> inline
-void ObjectBase::set_property(const Glib::ustring& property_name, const PropertyType& value)
+template <class PropertyType>
+inline void
+ObjectBase::set_property(const Glib::ustring& property_name, const PropertyType& value)
{
Glib::Value<PropertyType> property_value;
property_value.init(Glib::Value<PropertyType>::value_type());
@@ -278,8 +281,9 @@ void ObjectBase::set_property(const Glib::ustring& property_name, const Property
this->set_property_value(property_name, property_value);
}
-template <class PropertyType> inline
-void ObjectBase::get_property(const Glib::ustring& property_name, PropertyType& value) const
+template <class PropertyType>
+inline void
+ObjectBase::get_property(const Glib::ustring& property_name, PropertyType& value) const
{
Glib::Value<PropertyType> property_value;
property_value.init(Glib::Value<PropertyType>::value_type());
@@ -291,11 +295,8 @@ void ObjectBase::get_property(const Glib::ustring& property_name, PropertyType&
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
bool _gobject_cppinstance_already_deleted(GObject* gobject);
} // namespace Glib
-
#endif /* _GLIBMM_OBJECTBASE_H */
-
diff --git a/glib/glibmm/pattern.h b/glib/glibmm/pattern.h
index ff556bd..d588f08 100644
--- a/glib/glibmm/pattern.h
+++ b/glib/glibmm/pattern.h
@@ -23,11 +23,12 @@
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-extern "C" { typedef struct _GPatternSpec GPatternSpec; }
+extern "C" {
+typedef struct _GPatternSpec GPatternSpec;
+}
#include <glibmm/ustring.h>
-
namespace Glib
{
@@ -53,7 +54,7 @@ public:
bool operator==(const PatternSpec& rhs) const;
bool operator!=(const PatternSpec& rhs) const;
- GPatternSpec* gobj() { return gobject_; }
+ GPatternSpec* gobj() { return gobject_; }
const GPatternSpec* gobj() const { return gobject_; }
private:
@@ -64,6 +65,4 @@ private:
} // namespace Glib
-
#endif /* _GLIBMM_PATTERN_H */
-
diff --git a/glib/glibmm/priorities.h b/glib/glibmm/priorities.h
index 7d4782d..a856751 100644
--- a/glib/glibmm/priorities.h
+++ b/glib/glibmm/priorities.h
@@ -59,7 +59,6 @@ enum
PRIORITY_LOW = 300
};
-} //namespace Glib
+} // namespace Glib
#endif //#ifndef _GLIBMM_PRIORITIES_H
-
diff --git a/glib/glibmm/property.h b/glib/glibmm/property.h
index 023b0e4..3242bbd 100644
--- a/glib/glibmm/property.h
+++ b/glib/glibmm/property.h
@@ -28,20 +28,20 @@ namespace Glib
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#ifdef GLIBMM_CXX_CAN_USE_NAMESPACES_INSIDE_EXTERNC
-//For the AIX xlC compiler, I can not find a way to do this without putting the functions in the global
namespace. murrayc
-extern "C"
-{
-#endif //GLIBMM_CXX_CAN_USE_NAMESPACES_INSIDE_EXTERNC
+// For the AIX xlC compiler, I can not find a way to do this without putting the functions in the
+// global namespace. murrayc
+extern "C" {
+#endif // GLIBMM_CXX_CAN_USE_NAMESPACES_INSIDE_EXTERNC
-void custom_get_property_callback(GObject* object, unsigned int property_id,
- GValue* value, GParamSpec* param_spec);
+void custom_get_property_callback(
+ GObject* object, unsigned int property_id, GValue* value, GParamSpec* param_spec);
-void custom_set_property_callback(GObject* object, unsigned int property_id,
- const GValue* value, GParamSpec* param_spec);
+void custom_set_property_callback(
+ GObject* object, unsigned int property_id, const GValue* value, GParamSpec* param_spec);
#ifdef GLIBMM_CXX_CAN_USE_NAMESPACES_INSIDE_EXTERNC
-} //extern "C"
-#endif //GLIBMM_CXX_CAN_USE_NAMESPACES_INSIDE_EXTERNC
+} // extern "C"
+#endif // GLIBMM_CXX_CAN_USE_NAMESPACES_INSIDE_EXTERNC
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
@@ -53,7 +53,6 @@ void custom_set_property_callback(GObject* object, unsigned int property_id,
class PropertyBase
{
public:
-
// noncopyable
PropertyBase(const PropertyBase&) = delete;
PropertyBase& operator=(const PropertyBase&) = delete;
@@ -68,9 +67,9 @@ public:
void notify();
protected:
- Glib::Object* object_;
+ Glib::Object* object_;
Glib::ValueBase value_;
- GParamSpec* param_spec_;
+ GParamSpec* param_spec_;
/** This constructs a property of type @a value_type for the @a object.
* The property is not registered in the GObject object system
@@ -99,14 +98,13 @@ protected:
const char* get_name_internal() const;
private:
-
#ifndef DOXYGEN_SHOULD_SKIP_THIS
- friend void Glib::custom_get_property_callback(GObject* object, unsigned int property_id,
- GValue* value, GParamSpec* param_spec);
+ friend void Glib::custom_get_property_callback(
+ GObject* object, unsigned int property_id, GValue* value, GParamSpec* param_spec);
- friend void Glib::custom_set_property_callback(GObject* object, unsigned int property_id,
- const GValue* value, GParamSpec* param_spec);
+ friend void Glib::custom_set_property_callback(
+ GObject* object, unsigned int property_id, const GValue* value, GParamSpec* param_spec);
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
};
@@ -209,61 +207,62 @@ public:
inline Glib::PropertyProxy<T> get_proxy();
};
-
#ifndef DOXYGEN_SHOULD_SKIP_THIS
/**** Glib::Property<T> ****************************************************/
template <class T>
Property<T>::Property(Glib::Object& object, const Glib::ustring& name)
-:
- PropertyBase(object, ValueType::value_type())
+: PropertyBase(object, ValueType::value_type())
{
- if(!lookup_property(name))
+ if (!lookup_property(name))
install_property(static_cast<ValueType&>(value_).create_param_spec(name));
}
template <class T>
Property<T>::Property(Glib::Object& object, const Glib::ustring& name,
- const typename Property<T>::PropertyType& default_value)
-:
- PropertyBase(object, ValueType::value_type())
+ const typename Property<T>::PropertyType& default_value)
+: PropertyBase(object, ValueType::value_type())
{
static_cast<ValueType&>(value_).set(default_value);
- if(!lookup_property(name))
+ if (!lookup_property(name))
install_property(static_cast<ValueType&>(value_).create_param_spec(name));
}
-template <class T> inline
-void Property<T>::set_value(const typename Property<T>::PropertyType& data)
+template <class T>
+inline void
+Property<T>::set_value(const typename Property<T>::PropertyType& data)
{
static_cast<ValueType&>(value_).set(data);
this->notify();
}
-template <class T> inline
-typename Property<T>::PropertyType Property<T>::get_value() const
+template <class T>
+inline typename Property<T>::PropertyType
+Property<T>::get_value() const
{
return static_cast<const ValueType&>(value_).get();
}
-template <class T> inline
-Property<T>& Property<T>::operator=(const typename Property<T>::PropertyType& data)
+template <class T>
+inline Property<T>&
+Property<T>::operator=(const typename Property<T>::PropertyType& data)
{
static_cast<ValueType&>(value_).set(data);
this->notify();
return *this;
}
-template <class T> inline
-Property<T>::operator T() const
+template <class T>
+inline Property<T>::operator T() const
{
return static_cast<const ValueType&>(value_).get();
}
-template <class T> inline
-Glib::PropertyProxy<T> Property<T>::get_proxy()
+template <class T>
+inline Glib::PropertyProxy<T>
+Property<T>::get_proxy()
{
return Glib::PropertyProxy<T>(object_, get_name_internal());
}
@@ -272,6 +271,4 @@ Glib::PropertyProxy<T> Property<T>::get_proxy()
} // namespace Glib
-
#endif /* _GLIBMM_PROPERTY_H */
-
diff --git a/glib/glibmm/propertyproxy.h b/glib/glibmm/propertyproxy.h
index 5606503..1d47b3c 100644
--- a/glib/glibmm/propertyproxy.h
+++ b/glib/glibmm/propertyproxy.h
@@ -24,12 +24,12 @@
#include <glibmmconfig.h>
#include <glibmm/propertyproxy_base.h>
-
namespace Glib
{
/** A PropertyProxy can be used to get and set the value of an object's property.
- * There are usually also get and set methods on the class itself, which you might find more convenient.
+ * There are usually also get and set methods on the class itself, which you might find more
+ * convenient.
* With the PropertyProxy, you may use either get_value() and set_value(), or operator=() and
* operator PropertyType(), like so:
* @code
@@ -37,7 +37,8 @@ namespace Glib
* cellrenderer.property_editable() = true;
* @endcode
*
- * You may also receive notification when a property's value changes, by connecting to signal_changed().
+ * You may also receive notification when a property's value changes, by connecting to
+ * signal_changed().
*/
template <class T>
class PropertyProxy : public PropertyProxy_Base
@@ -45,8 +46,7 @@ class PropertyProxy : public PropertyProxy_Base
public:
typedef T PropertyType;
- PropertyProxy(ObjectBase* obj, const char* name)
- : PropertyProxy_Base(obj, name) {}
+ PropertyProxy(ObjectBase* obj, const char* name) : PropertyProxy_Base(obj, name) {}
/** Set the value of this property.
* @param data The new value for the property.
@@ -60,17 +60,17 @@ public:
/** Set the value of this property back to its default value
*/
- void reset_value()
- { reset_property_(); }
+ void reset_value() { reset_property_(); }
PropertyProxy<T>& operator=(const PropertyType& data)
- { this->set_value(data); return *this; }
+ {
+ this->set_value(data);
+ return *this;
+ }
- operator PropertyType() const
- { return this->get_value(); }
+ operator PropertyType() const { return this->get_value(); }
};
-
/** See PropertyProxy().
* This property can be written, but not read, so there is no get_value() method.
*/
@@ -80,8 +80,7 @@ class PropertyProxy_WriteOnly : public PropertyProxy_Base
public:
typedef T PropertyType;
- PropertyProxy_WriteOnly(ObjectBase* obj, const char* name)
- : PropertyProxy_Base(obj, name) {}
+ PropertyProxy_WriteOnly(ObjectBase* obj, const char* name) : PropertyProxy_Base(obj, name) {}
/** Set the value of this property.
* @param data The new value for the property.
@@ -90,11 +89,13 @@ public:
/** Set the value of this property back to its default value
*/
- void reset_value()
- { reset_property_(); }
+ void reset_value() { reset_property_(); }
PropertyProxy_WriteOnly<T>& operator=(const PropertyType& data)
- { this->set_value(data); return *this; }
+ {
+ this->set_value(data);
+ return *this;
+ }
};
/** See PropertyProxy().
@@ -106,26 +107,27 @@ class PropertyProxy_ReadOnly : public PropertyProxy_Base
public:
typedef T PropertyType;
- //obj is const, because this should be returned by const accessors.
+ // obj is const, because this should be returned by const accessors.
PropertyProxy_ReadOnly(const ObjectBase* obj, const char* name)
- : PropertyProxy_Base(const_cast<ObjectBase*>(obj), name) {}
+ : PropertyProxy_Base(const_cast<ObjectBase*>(obj), name)
+ {
+ }
/** Get the value of this property.
* @result The current value of the property.
*/
PropertyType get_value() const;
- operator PropertyType() const
- { return this->get_value(); }
+ operator PropertyType() const { return this->get_value(); }
};
-
/**** Template Implementation **********************************************/
#ifndef DOXYGEN_SHOULD_SKIP_THIS
template <class T>
-void PropertyProxy<T>::set_value(const T& data)
+void
+PropertyProxy<T>::set_value(const T& data)
{
Glib::Value<T> value;
value.init(Glib::Value<T>::value_type());
@@ -135,7 +137,8 @@ void PropertyProxy<T>::set_value(const T& data)
}
template <class T>
-T PropertyProxy<T>::get_value() const
+T
+PropertyProxy<T>::get_value() const
{
Glib::Value<T> value;
value.init(Glib::Value<T>::value_type());
@@ -144,11 +147,13 @@ T PropertyProxy<T>::get_value() const
return value.get();
}
-//We previously just static_cast<> PropertyProxy_WriteOnly<> to PropertyProxy<> to call its set_value(),
-//to avoid code duplication.
-//But the AIX compiler does not like that hack.
+// We previously just static_cast<> PropertyProxy_WriteOnly<> to PropertyProxy<> to call its
+// set_value(),
+// to avoid code duplication.
+// But the AIX compiler does not like that hack.
template <class T>
-void PropertyProxy_WriteOnly<T>::set_value(const T& data)
+void
+PropertyProxy_WriteOnly<T>::set_value(const T& data)
{
Glib::Value<T> value;
value.init(Glib::Value<T>::value_type());
@@ -157,11 +162,13 @@ void PropertyProxy_WriteOnly<T>::set_value(const T& data)
set_property_(value);
}
-//We previously just static_cast<> PropertyProxy_WriteOnly<> to PropertyProxy<> to call its set_value(),
-//to avoid code duplication.
-//But the AIX compiler does not like that hack.
+// We previously just static_cast<> PropertyProxy_WriteOnly<> to PropertyProxy<> to call its
+// set_value(),
+// to avoid code duplication.
+// But the AIX compiler does not like that hack.
template <class T>
-T PropertyProxy_ReadOnly<T>::get_value() const
+T
+PropertyProxy_ReadOnly<T>::get_value() const
{
Glib::Value<T> value;
value.init(Glib::Value<T>::value_type());
@@ -174,6 +181,4 @@ T PropertyProxy_ReadOnly<T>::get_value() const
} // namespace Glib
-
#endif /* _GLIBMM_PROPERTYPROXY_H */
-
diff --git a/glib/glibmm/propertyproxy_base.h b/glib/glibmm/propertyproxy_base.h
index 1045c5c..c939b5c 100644
--- a/glib/glibmm/propertyproxy_base.h
+++ b/glib/glibmm/propertyproxy_base.h
@@ -27,10 +27,10 @@
namespace Glib
{
-
class ObjectBase;
-/// Use the connect() method, with sigc::ptr_fun() or sig::mem_fun() to connect signals to signal handlers.
+/// Use the connect() method, with sigc::ptr_fun() or sig::mem_fun() to connect signals to signal
+/// handlers.
class SignalProxyProperty : public SignalProxyBase
{
public:
@@ -46,24 +46,22 @@ public:
sigc::connection connect(SlotType&& slot);
protected:
-
- const char* property_name_; //Should be a static string literal.
+ const char* property_name_; // Should be a static string literal.
private:
SignalProxyProperty& operator=(const SignalProxyProperty&); // not implemented
};
-
class PropertyProxy_Base
{
public:
PropertyProxy_Base(ObjectBase* obj, const char* property_name);
PropertyProxy_Base(const PropertyProxy_Base& other);
- ///This signal will be emitted when the property changes.
+ /// This signal will be emitted when the property changes.
SignalProxyProperty signal_changed();
- ObjectBase* get_object() const { return obj_; }
+ ObjectBase* get_object() const { return obj_; }
const char* get_name() const { return property_name_; }
protected:
@@ -71,16 +69,15 @@ protected:
void get_property_(Glib::ValueBase& value) const;
void reset_property_();
- ObjectBase* obj_; //The C++ wrapper instance of which this PropertyProxy is a member.
+ ObjectBase* obj_; // The C++ wrapper instance of which this PropertyProxy is a member.
- const char* property_name_; //Should be a static string literal.
+ const char* property_name_; // Should be a static string literal.
private:
- //Declared as private, but not implemented to prevent any automatically generated implementation.
+ // Declared as private, but not implemented to prevent any automatically generated implementation.
PropertyProxy_Base& operator=(const PropertyProxy_Base&);
};
-
#ifndef DOXYGEN_SHOULD_SKIP_THIS
class SignalProxyProperty;
diff --git a/glib/glibmm/quark.h b/glib/glibmm/quark.h
index 5eac617..ae0731c 100644
--- a/glib/glibmm/quark.h
+++ b/glib/glibmm/quark.h
@@ -43,36 +43,42 @@ namespace Glib
*/
class QueryQuark
{
- public:
- QueryQuark(const GQuark& q);
- QueryQuark(const ustring& s);
- QueryQuark(const char*s);
- ~QueryQuark() noexcept {}
- QueryQuark& operator=(const QueryQuark& q);
- operator ustring() const;
+public:
+ QueryQuark(const GQuark& q);
+ QueryQuark(const ustring& s);
+ QueryQuark(const char* s);
+ ~QueryQuark() noexcept {}
+ QueryQuark& operator=(const QueryQuark& q);
+ operator ustring() const;
- operator GQuark() const {return quark_;}
- GQuark id() const {return quark_;}
+ operator GQuark() const { return quark_; }
+ GQuark id() const { return quark_; }
- private:
- GQuark quark_;
+private:
+ GQuark quark_;
};
-class Quark: public QueryQuark
+class Quark : public QueryQuark
{
- public:
- Quark(const ustring& s);
- Quark(const char* s);
- ~Quark() noexcept;
+public:
+ Quark(const ustring& s);
+ Quark(const char* s);
+ ~Quark() noexcept;
};
/** @relates Glib::QueryQuark */
-inline bool operator==(const QueryQuark& a, const QueryQuark& b)
- { return a.id() == b.id(); }
+inline bool
+operator==(const QueryQuark& a, const QueryQuark& b)
+{
+ return a.id() == b.id();
+}
/** @relates Glib::QueryQuark */
-inline bool operator!=(const QueryQuark& a, const QueryQuark& b)
- { return a.id() != b.id(); }
+inline bool
+operator!=(const QueryQuark& a, const QueryQuark& b)
+{
+ return a.id() != b.id();
+}
#ifndef DOXYGEN_SHOULD_SKIP_THIS
// TODO: Put this somewhere else.
@@ -84,4 +90,3 @@ extern GLIBMM_API GQuark quark_cpp_wrapper_deleted_;
} /* namespace Glib */
#endif /* _GLIBMM_QUARK_H */
-
diff --git a/glib/glibmm/random.h b/glib/glibmm/random.h
index cd6bb77..d39660f 100644
--- a/glib/glibmm/random.h
+++ b/glib/glibmm/random.h
@@ -25,8 +25,9 @@
#include <glib.h>
-extern "C" { typedef struct _GRand GRand; }
-
+extern "C" {
+typedef struct _GRand GRand;
+}
namespace Glib
{
@@ -52,12 +53,12 @@ public:
bool get_bool();
guint32 get_int();
- gint32 get_int_range(gint32 begin, gint32 end);
+ gint32 get_int_range(gint32 begin, gint32 end);
double get_double();
double get_double_range(double begin, double end);
- GRand* gobj() { return gobject_; }
+ GRand* gobj() { return gobject_; }
const GRand* gobj() const { return gobject_; }
private:
@@ -68,6 +69,4 @@ private:
} // namespace Glib
-
#endif /* _GLIBMM_RANDOM_H */
-
diff --git a/glib/glibmm/refptr.h b/glib/glibmm/refptr.h
index 5402241..c9acef2 100644
--- a/glib/glibmm/refptr.h
+++ b/glib/glibmm/refptr.h
@@ -82,8 +82,7 @@ private:
static const bool value = sizeof(check(static_cast<T_CppObject*>(nullptr))) == sizeof(big);
};
- static_assert(is_allowed_type::value,
- "Glib::RefPtr must not be used with this class.");
+ static_assert(is_allowed_type::value, "Glib::RefPtr must not be used with this class.");
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
public:
@@ -169,18 +168,21 @@ public:
inline operator bool() const noexcept;
#ifndef GLIBMM_DISABLE_DEPRECATED
- /// @deprecated Use reset() instead because this leads to confusion with clear() methods on the underlying
class. For instance, people use .clear() when they mean ->clear().
+ /// @deprecated Use reset() instead because this leads to confusion with clear() methods on the
+ /// underlying class. For instance, people use .clear() when they mean ->clear().
inline void clear() noexcept;
-#endif //GLIBMM_DISABLE_DEPRECATED
+#endif // GLIBMM_DISABLE_DEPRECATED
- /** Set underlying instance to nullptr, decrementing reference count of existing instance appropriately.
+ /** Set underlying instance to nullptr, decrementing reference count of existing instance
+ * appropriately.
* @newin{2,16}
*/
inline void reset() noexcept;
/** Release the ownership of underlying instance.
*
- * RefPtr's underlying instance is set to nullptr, therefore underlying object can't be accessed through
this RefPtr anymore.
+ * RefPtr's underlying instance is set to nullptr, therefore underlying object can't be accessed
+ * through this RefPtr anymore.
* @return an underlying instance.
*
* Most users should not use release(). It can spoil the automatic destruction
@@ -219,9 +221,9 @@ public:
template <class T_CastFrom>
static inline RefPtr cast_const(const RefPtr<T_CastFrom>& src) noexcept;
- //TODO: Maybe remove these if we replace operator bool() with operator const void* after
- //an API/ABI break, as suggested by Daniel Elstner? murrayc.
- //See bug https://bugzilla.gnome.org/show_bug.cgi?id=626858
+ // TODO: Maybe remove these if we replace operator bool() with operator const void* after
+ // an API/ABI break, as suggested by Daniel Elstner? murrayc.
+ // See bug https://bugzilla.gnome.org/show_bug.cgi?id=626858
/** Compare based on the underlying instance address.
*
@@ -247,60 +249,50 @@ private:
T_CppObject* pCppObject_;
};
-
#ifndef DOXYGEN_SHOULD_SKIP_THIS
// RefPtr<>::operator->() comes first here since it's used by other methods.
// If it would come after them it wouldn't be inlined.
-template <class T_CppObject> inline
-T_CppObject* RefPtr<T_CppObject>::operator->() const noexcept
+template <class T_CppObject>
+inline T_CppObject* RefPtr<T_CppObject>::operator->() const noexcept
{
return pCppObject_;
}
-template <class T_CppObject> inline
-RefPtr<T_CppObject>::RefPtr() noexcept
-:
- pCppObject_ (nullptr)
-{}
+template <class T_CppObject>
+inline RefPtr<T_CppObject>::RefPtr() noexcept : pCppObject_(nullptr)
+{
+}
-template <class T_CppObject> inline
-RefPtr<T_CppObject>::~RefPtr() noexcept
+template <class T_CppObject>
+inline RefPtr<T_CppObject>::~RefPtr() noexcept
{
- if(pCppObject_)
+ if (pCppObject_)
pCppObject_->unreference(); // This could cause pCppObject to be deleted.
}
-template <class T_CppObject> inline
-RefPtr<T_CppObject>::RefPtr(T_CppObject* pCppObject) noexcept
-:
- pCppObject_ (pCppObject)
-{}
+template <class T_CppObject>
+inline RefPtr<T_CppObject>::RefPtr(T_CppObject* pCppObject) noexcept : pCppObject_(pCppObject)
+{
+}
-template <class T_CppObject> inline
-RefPtr<T_CppObject>::RefPtr(const RefPtr& src) noexcept
-:
- pCppObject_ (src.pCppObject_)
+template <class T_CppObject>
+inline RefPtr<T_CppObject>::RefPtr(const RefPtr& src) noexcept : pCppObject_(src.pCppObject_)
{
- if(pCppObject_)
+ if (pCppObject_)
pCppObject_->reference();
}
-template <class T_CppObject> inline
-RefPtr<T_CppObject>::RefPtr(RefPtr&& src) noexcept
-:
- pCppObject_ (src.pCppObject_)
+template <class T_CppObject>
+inline RefPtr<T_CppObject>::RefPtr(RefPtr&& src) noexcept : pCppObject_(src.pCppObject_)
{
src.pCppObject_ = nullptr;
}
template <class T_CppObject>
- template <class T_CastFrom>
-inline
-RefPtr<T_CppObject>::RefPtr(RefPtr<T_CastFrom>&& src) noexcept
-:
- pCppObject_ (src.release())
+template <class T_CastFrom>
+inline RefPtr<T_CppObject>::RefPtr(RefPtr<T_CastFrom>&& src) noexcept : pCppObject_(src.release())
{
}
@@ -308,29 +300,29 @@ RefPtr<T_CppObject>::RefPtr(RefPtr<T_CastFrom>&& src) noexcept
// castable. Thus, it does downcasts:
// base_ref = derived_ref
template <class T_CppObject>
- template <class T_CastFrom>
-inline
-RefPtr<T_CppObject>::RefPtr(const RefPtr<T_CastFrom>& src) noexcept
-:
+template <class T_CastFrom>
+inline RefPtr<T_CppObject>::RefPtr(const RefPtr<T_CastFrom>& src) noexcept :
// A different RefPtr<> will not allow us access to pCppObject_. We need
// to add a get_underlying() for this, but that would encourage incorrect
// use, so we use the less well-known operator->() accessor:
- pCppObject_ (src.operator->())
+ pCppObject_(src.operator->())
{
- if(pCppObject_)
+ if (pCppObject_)
pCppObject_->reference();
}
-template <class T_CppObject> inline
-void RefPtr<T_CppObject>::swap(RefPtr& other) noexcept
+template <class T_CppObject>
+inline void
+RefPtr<T_CppObject>::swap(RefPtr& other) noexcept
{
- T_CppObject *const temp = pCppObject_;
+ T_CppObject* const temp = pCppObject_;
pCppObject_ = other.pCppObject_;
other.pCppObject_ = temp;
}
-template <class T_CppObject> inline
-RefPtr<T_CppObject>& RefPtr<T_CppObject>::operator=(const RefPtr& src) noexcept
+template <class T_CppObject>
+inline RefPtr<T_CppObject>&
+RefPtr<T_CppObject>::operator=(const RefPtr& src) noexcept
{
// In case you haven't seen the swap() technique to implement copy
// assignment before, here's what it does:
@@ -356,15 +348,16 @@ RefPtr<T_CppObject>& RefPtr<T_CppObject>::operator=(const RefPtr& src) noexcept
// even thinking about it to implement copy assignment whereever the
// object data is managed indirectly via a pointer, which is very common.
- RefPtr<T_CppObject> temp (src);
+ RefPtr<T_CppObject> temp(src);
this->swap(temp);
return *this;
}
-template <class T_CppObject> inline
-RefPtr<T_CppObject>& RefPtr<T_CppObject>::operator=(RefPtr&& src) noexcept
+template <class T_CppObject>
+inline RefPtr<T_CppObject>&
+RefPtr<T_CppObject>::operator=(RefPtr&& src) noexcept
{
- RefPtr<T_CppObject> temp (std::move(src));
+ RefPtr<T_CppObject> temp(std::move(src));
this->swap(temp);
src.pCppObject_ = nullptr;
@@ -372,9 +365,9 @@ RefPtr<T_CppObject>& RefPtr<T_CppObject>::operator=(RefPtr&& src) noexcept
}
template <class T_CppObject>
- template <class T_CastFrom>
-inline
-RefPtr<T_CppObject>& RefPtr<T_CppObject>::operator=(RefPtr<T_CastFrom>&& src) noexcept
+template <class T_CastFrom>
+inline RefPtr<T_CppObject>&
+RefPtr<T_CppObject>::operator=(RefPtr<T_CastFrom>&& src) noexcept
{
if (pCppObject_)
pCppObject_->unreference();
@@ -384,115 +377,124 @@ RefPtr<T_CppObject>& RefPtr<T_CppObject>::operator=(RefPtr<T_CastFrom>&& src) no
}
template <class T_CppObject>
- template <class T_CastFrom>
-inline
-RefPtr<T_CppObject>& RefPtr<T_CppObject>::operator=(const RefPtr<T_CastFrom>& src) noexcept
+template <class T_CastFrom>
+inline RefPtr<T_CppObject>&
+RefPtr<T_CppObject>::operator=(const RefPtr<T_CastFrom>& src) noexcept
{
- RefPtr<T_CppObject> temp (src);
+ RefPtr<T_CppObject> temp(src);
this->swap(temp);
return *this;
}
-template <class T_CppObject> inline
-bool RefPtr<T_CppObject>::operator==(const RefPtr& src) const noexcept
+template <class T_CppObject>
+inline bool
+RefPtr<T_CppObject>::operator==(const RefPtr& src) const noexcept
{
return (pCppObject_ == src.pCppObject_);
}
-template <class T_CppObject> inline
-bool RefPtr<T_CppObject>::operator!=(const RefPtr& src) const noexcept
+template <class T_CppObject>
+inline bool
+RefPtr<T_CppObject>::operator!=(const RefPtr& src) const noexcept
{
return (pCppObject_ != src.pCppObject_);
}
-template <class T_CppObject> inline
-RefPtr<T_CppObject>::operator bool() const noexcept
+template <class T_CppObject>
+inline RefPtr<T_CppObject>::operator bool() const noexcept
{
return (pCppObject_ != nullptr);
}
#ifndef GLIBMM_DISABLE_DEPRECATED
-template <class T_CppObject> inline
-void RefPtr<T_CppObject>::clear() noexcept
+template <class T_CppObject>
+inline void
+RefPtr<T_CppObject>::clear() noexcept
{
reset();
}
-#endif //GLIBMM_DISABLE_DEPRECATED
+#endif // GLIBMM_DISABLE_DEPRECATED
-template <class T_CppObject> inline
-void RefPtr<T_CppObject>::reset() noexcept
+template <class T_CppObject>
+inline void
+RefPtr<T_CppObject>::reset() noexcept
{
RefPtr<T_CppObject> temp; // swap with an empty RefPtr<> to clear *this
this->swap(temp);
}
-template <class T_CppObject> inline
-T_CppObject* RefPtr<T_CppObject>::release() noexcept
+template <class T_CppObject>
+inline T_CppObject*
+RefPtr<T_CppObject>::release() noexcept
{
- T_CppObject *tmp = pCppObject_;
+ T_CppObject* tmp = pCppObject_;
pCppObject_ = nullptr;
return tmp;
}
template <class T_CppObject>
- template <class T_CastFrom>
-inline
-RefPtr<T_CppObject> RefPtr<T_CppObject>::cast_dynamic(const RefPtr<T_CastFrom>& src) noexcept
+template <class T_CastFrom>
+inline RefPtr<T_CppObject>
+RefPtr<T_CppObject>::cast_dynamic(const RefPtr<T_CastFrom>& src) noexcept
{
- T_CppObject *const pCppObject = dynamic_cast<T_CppObject*>(src.operator->());
+ T_CppObject* const pCppObject = dynamic_cast<T_CppObject*>(src.operator->());
- if(pCppObject)
+ if (pCppObject)
pCppObject->reference();
return RefPtr<T_CppObject>(pCppObject);
}
template <class T_CppObject>
- template <class T_CastFrom>
-inline
-RefPtr<T_CppObject> RefPtr<T_CppObject>::cast_static(const RefPtr<T_CastFrom>& src) noexcept
+template <class T_CastFrom>
+inline RefPtr<T_CppObject>
+RefPtr<T_CppObject>::cast_static(const RefPtr<T_CastFrom>& src) noexcept
{
- T_CppObject *const pCppObject = static_cast<T_CppObject*>(src.operator->());
+ T_CppObject* const pCppObject = static_cast<T_CppObject*>(src.operator->());
- if(pCppObject)
+ if (pCppObject)
pCppObject->reference();
return RefPtr<T_CppObject>(pCppObject);
}
template <class T_CppObject>
- template <class T_CastFrom>
-inline
-RefPtr<T_CppObject> RefPtr<T_CppObject>::cast_const(const RefPtr<T_CastFrom>& src) noexcept
+template <class T_CastFrom>
+inline RefPtr<T_CppObject>
+RefPtr<T_CppObject>::cast_const(const RefPtr<T_CastFrom>& src) noexcept
{
- T_CppObject *const pCppObject = const_cast<T_CppObject*>(src.operator->());
+ T_CppObject* const pCppObject = const_cast<T_CppObject*>(src.operator->());
- if(pCppObject)
+ if (pCppObject)
pCppObject->reference();
return RefPtr<T_CppObject>(pCppObject);
}
-template <class T_CppObject> inline
-bool RefPtr<T_CppObject>::operator<(const RefPtr& src) const noexcept
+template <class T_CppObject>
+inline bool
+RefPtr<T_CppObject>::operator<(const RefPtr& src) const noexcept
{
return (pCppObject_ < src.pCppObject_);
}
-template <class T_CppObject> inline
-bool RefPtr<T_CppObject>::operator<=(const RefPtr& src) const noexcept
+template <class T_CppObject>
+inline bool
+RefPtr<T_CppObject>::operator<=(const RefPtr& src) const noexcept
{
return (pCppObject_ <= src.pCppObject_);
}
-template <class T_CppObject> inline
-bool RefPtr<T_CppObject>::operator>(const RefPtr& src) const noexcept
+template <class T_CppObject>
+inline bool
+RefPtr<T_CppObject>::operator>(const RefPtr& src) const noexcept
{
return (pCppObject_ > src.pCppObject_);
}
-template <class T_CppObject> inline
-bool RefPtr<T_CppObject>::operator>=(const RefPtr& src) const noexcept
+template <class T_CppObject>
+inline bool
+RefPtr<T_CppObject>::operator>=(const RefPtr& src) const noexcept
{
return (pCppObject_ >= src.pCppObject_);
}
@@ -500,14 +502,13 @@ bool RefPtr<T_CppObject>::operator>=(const RefPtr& src) const noexcept
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
/** @relates Glib::RefPtr */
-template <class T_CppObject> inline
-void swap(RefPtr<T_CppObject>& lhs, RefPtr<T_CppObject>& rhs) noexcept
+template <class T_CppObject>
+inline void
+swap(RefPtr<T_CppObject>& lhs, RefPtr<T_CppObject>& rhs) noexcept
{
lhs.swap(rhs);
}
} // namespace Glib
-
#endif /* _GLIBMM_REFPTR_H */
-
diff --git a/glib/glibmm/sarray.h b/glib/glibmm/sarray.h
index 2ec2fea..31f139b 100644
--- a/glib/glibmm/sarray.h
+++ b/glib/glibmm/sarray.h
@@ -26,15 +26,15 @@
#include <glibmm/arrayhandle.h>
#include <glibmm/ustring.h>
-namespace Glib {
+namespace Glib
+{
/**
* @deprecated Use a std::vector instead.
*/
typedef Glib::ArrayHandle<Glib::ustring> SArray;
-
}
-#endif //GLIBMM_DISABLE_DEPRECATED
+#endif // GLIBMM_DISABLE_DEPRECATED
#endif // _GLIBMM_SARRAY_H
diff --git a/glib/glibmm/signalproxy.h b/glib/glibmm/signalproxy.h
index f6f3548..932f886 100644
--- a/glib/glibmm/signalproxy.h
+++ b/glib/glibmm/signalproxy.h
@@ -20,10 +20,9 @@
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-extern "C"
-{
- typedef void (*GCallback) (void);
- typedef struct _GObject GObject;
+extern "C" {
+typedef void (*GCallback)(void);
+typedef struct _GObject GObject;
}
#include <sigc++/sigc++.h>
@@ -42,11 +41,11 @@ class ObjectBase;
struct SignalProxyInfo
{
const char* signal_name;
- GCallback callback;
- GCallback notify_callback;
+ GCallback callback;
+ GCallback notify_callback;
};
-#endif //DOXYGEN_SHOULD_SKIP_THIS
+#endif // DOXYGEN_SHOULD_SKIP_THIS
// This base class is used by SignalProxyNormal, SignalProxyDetailed and SignalProxyProperty.
class SignalProxyBase
@@ -71,7 +70,6 @@ private:
SignalProxyBase& operator=(const SignalProxyBase&); // not implemented
};
-
// Shared portion of a Signal without detail
/** The SignalProxy provides an API similar to sigc::signal that can be used to
* connect sigc::slots to glib signals.
@@ -98,10 +96,10 @@ public:
#endif
protected:
-
/** Creates a proxy for a signal that can be emitted by @a obj.
* @param obj The object that can emit the signal.
- * @param info Information about the signal, including its name, and the C callbacks that should be called
by glib.
+ * @param info Information about the signal, including its name, and the C callbacks that should
+ * be called by glib.
*/
SignalProxyNormal(Glib::ObjectBase* obj, const SignalProxyInfo* info);
@@ -109,7 +107,8 @@ protected:
* This is called by connect() in derived SignalProxy classes.
*
* @param slot The signal handler, usually created with sigc::mem_fun() or sigc::ptr_fun().
- * @param after Whether this signal handler should be called before or after the default signal handler.
+ * @param after Whether this signal handler should be called before or after the default signal
+ * handler.
*/
sigc::slot_base& connect_(const sigc::slot_base& slot, bool after);
@@ -118,7 +117,8 @@ protected:
*
* @param slot The signal handler, which should have a @c void return type,
* usually created with sigc::mem_fun() or sigc::ptr_fun().
- * @param after Whether this signal handler should be called before or after the default signal handler.
+ * @param after Whether this signal handler should be called before or after the default signal
+ * handler.
*/
sigc::slot_base& connect_notify_(const sigc::slot_base& slot, bool after);
@@ -133,7 +133,8 @@ protected:
private:
const SignalProxyInfo* info_;
- //TODO: We could maybe replace both connect_() and connect_notify_() with this in future, because they
don't do anything extra.
+ // TODO: We could maybe replace both connect_() and connect_notify_() with this in future, because
+ // they don't do anything extra.
/** This is called by connect_() and connect_notify_().
*/
sigc::slot_base& connect_impl_(GCallback callback, const sigc::slot_base& slot, bool after);
@@ -148,25 +149,27 @@ private:
* Use the connect() or connect_notify() method, with sigc::mem_fun() or sigc::ptr_fun()
* to connect signal handlers to signals.
*/
-template <class R, class ...T>
+template <class R, class... T>
class SignalProxy : public SignalProxyNormal
{
public:
- typedef sigc::slot<R, T...> SlotType;
+ typedef sigc::slot<R, T...> SlotType;
typedef sigc::slot<void, T...> VoidSlotType;
- SignalProxy(ObjectBase* obj, const SignalProxyInfo* info)
- : SignalProxyNormal(obj, info) {}
+ SignalProxy(ObjectBase* obj, const SignalProxyInfo* info) : SignalProxyNormal(obj, info) {}
/** Connects a signal handler to a signal.
*
* For instance, connect( sigc::mem_fun(*this, &TheClass::on_something) );
*
* @param slot The signal handler, usually created with sigc::mem_fun() or sigc::ptr_fun().
- * @param after Whether this signal handler should be called before or after the default signal handler.
+ * @param after Whether this signal handler should be called before or after the default signal
+ * handler.
*/
sigc::connection connect(const SlotType& slot, bool after = true)
- { return sigc::connection(connect_(slot, after)); }
+ {
+ return sigc::connection(connect_(slot, after));
+ }
/** Connects a signal handler to a signal.
* @see connect(const SlotType& slot, bool after).
@@ -174,7 +177,9 @@ public:
* @newin{2,48}
*/
sigc::connection connect(SlotType&& slot, bool after = true)
- { return sigc::connection(connect_impl_(false, std::move(slot), after)); }
+ {
+ return sigc::connection(connect_impl_(false, std::move(slot), after));
+ }
/** Connects a signal handler without a return value to a signal.
* By default, the signal handler will be called before the default signal handler.
@@ -190,15 +195,19 @@ public:
* For instance, if the return type is @c bool, the following two calls are equivalent.
* @code
* connect_notify( sigc::mem_fun(*this, &TheClass::on_something) );
- * connect( sigc::bind_return<bool>(sigc::mem_fun(*this, &TheClass::on_something), false), false );
+ * connect( sigc::bind_return<bool>(sigc::mem_fun(*this, &TheClass::on_something), false), false
+ * );
* @endcode
*
* @param slot The signal handler, which should have a @c void return type,
* usually created with sigc::mem_fun() or sigc::ptr_fun().
- * @param after Whether this signal handler should be called before or after the default signal handler.
+ * @param after Whether this signal handler should be called before or after the default signal
+ * handler.
*/
sigc::connection connect_notify(const VoidSlotType& slot, bool after = false)
- { return sigc::connection(connect_notify_(slot, after)); }
+ {
+ return sigc::connection(connect_notify_(slot, after));
+ }
/** Connects a signal handler without a return value to a signal.
* @see connect_notify(const VoidSlotType& slot, bool after).
@@ -206,7 +215,9 @@ public:
* @newin{2,48}
*/
sigc::connection connect_notify(VoidSlotType&& slot, bool after = false)
- { return sigc::connection(connect_impl_(true, std::move(slot), after)); }
+ {
+ return sigc::connection(connect_impl_(true, std::move(slot), after));
+ }
};
/* Templates below has been added to avoid API break, and should not be
@@ -228,8 +239,7 @@ using SignalProxy5 = SignalProxy<R, T1, T2, T3, T4, T5>;
template <typename R, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
using SignalProxy6 = SignalProxy<R, T1, T2, T3, T4, T5, T6>;
-
-//TODO: When we can break ABI, consider renaming
+// TODO: When we can break ABI, consider renaming
// SignalProxyDetailed => SignalProxyDetailedBase
// SignalProxyDetailedAnyType => SignalProxyDetailed
@@ -251,21 +261,22 @@ public:
void emission_stop();
protected:
-
/** Creates a proxy for a signal that can be emitted by @a obj.
* @param obj The object that can emit the signal.
* @param info Information about the signal, including its name
* and the C callbacks that should be called by glib.
* @param detail_name The detail name, if any.
*/
- SignalProxyDetailed(Glib::ObjectBase* obj, const SignalProxyInfo* info, const Glib::ustring& detail_name);
+ SignalProxyDetailed(
+ Glib::ObjectBase* obj, const SignalProxyInfo* info, const Glib::ustring& detail_name);
/** Connects a signal handler to a signal.
* This is called by connect() and connect_notify() in derived SignalProxyDetailedAnyType classes.
*
* @param notify Whether this method is called by connect_notify() or by connect().
* @param slot The signal handler, usually created with sigc::mem_fun() or sigc::ptr_fun().
- * @param after Whether this signal handler should be called before or after the default signal handler.
+ * @param after Whether this signal handler should be called before or after the default signal
+ * handler.
*/
sigc::slot_base& connect_impl_(bool notify, const sigc::slot_base& slot, bool after);
@@ -277,7 +288,7 @@ protected:
sigc::slot_base& connect_impl_(bool notify, sigc::slot_base&& slot, bool after);
private:
- const SignalProxyInfo* info_; // Pointer to statically allocated structure.
+ const SignalProxyInfo* info_; // Pointer to statically allocated structure.
const Glib::ustring detailed_name_; // signal_name[::detail_name]
// no copy assignment
@@ -288,25 +299,31 @@ private:
* Use the connect() or connect_notify() method, with sigc::mem_fun() or sigc::ptr_fun()
* to connect signal handlers to signals.
*/
-template <class R,class ...T>
+template <class R, class... T>
class SignalProxyDetailedAnyType : public SignalProxyDetailed
{
public:
- typedef sigc::slot<R,T...> SlotType;
- typedef sigc::slot<void,T...> VoidSlotType;
+ typedef sigc::slot<R, T...> SlotType;
+ typedef sigc::slot<void, T...> VoidSlotType;
- SignalProxyDetailedAnyType(ObjectBase* obj, const SignalProxyInfo* info, const Glib::ustring& detail_name)
- : SignalProxyDetailed(obj, info, detail_name) {}
+ SignalProxyDetailedAnyType(
+ ObjectBase* obj, const SignalProxyInfo* info, const Glib::ustring& detail_name)
+ : SignalProxyDetailed(obj, info, detail_name)
+ {
+ }
/** Connects a signal handler to a signal.
*
* For instance, connect( sigc::mem_fun(*this, &TheClass::on_something) );
*
* @param slot The signal handler, usually created with sigc::mem_fun() or sigc::ptr_fun().
- * @param after Whether this signal handler should be called before or after the default signal handler.
+ * @param after Whether this signal handler should be called before or after the default signal
+ * handler.
*/
sigc::connection connect(const SlotType& slot, bool after = true)
- { return sigc::connection(connect_impl_(false, slot, after)); }
+ {
+ return sigc::connection(connect_impl_(false, slot, after));
+ }
/** Connects a signal handler to a signal.
* @see connect(const SlotType& slot, bool after).
@@ -314,7 +331,9 @@ public:
* @newin{2,48}
*/
sigc::connection connect(SlotType&& slot, bool after = true)
- { return sigc::connection(connect_impl_(false, std::move(slot), after)); }
+ {
+ return sigc::connection(connect_impl_(false, std::move(slot), after));
+ }
/** Connects a signal handler without a return value to a signal.
* By default, the signal handler will be called before the default signal handler.
@@ -330,15 +349,19 @@ public:
* For instance, if the return type is @c bool, the following two calls are equivalent.
* @code
* connect_notify( sigc::mem_fun(*this, &TheClass::on_something) );
- * connect( sigc::bind_return<bool>(sigc::mem_fun(*this, &TheClass::on_something), false), false );
+ * connect( sigc::bind_return<bool>(sigc::mem_fun(*this, &TheClass::on_something), false), false
+ * );
* @endcode
*
* @param slot The signal handler, which should have a @c void return type,
* usually created with sigc::mem_fun() or sigc::ptr_fun().
- * @param after Whether this signal handler should be called before or after the default signal handler.
+ * @param after Whether this signal handler should be called before or after the default signal
+ * handler.
*/
sigc::connection connect_notify(const VoidSlotType& slot, bool after = false)
- { return sigc::connection(connect_impl_(true, slot, after)); }
+ {
+ return sigc::connection(connect_impl_(true, slot, after));
+ }
/** Connects a signal handler without a return value to a signal.
* @see connect_notify(const VoidSlotType& slot, bool after).
@@ -346,7 +369,9 @@ public:
* @newin{2,48}
*/
sigc::connection connect_notify(VoidSlotType&& slot, bool after = false)
- { return sigc::connection(connect_impl_(true, std::move(slot), after)); }
+ {
+ return sigc::connection(connect_impl_(true, std::move(slot), after));
+ }
};
/* Templates below has been added to avoid API break, and should not be
@@ -367,8 +392,7 @@ template <typename R, typename T1, typename T2, typename T3, typename T4, typena
using SignalProxyDetailed5 = SignalProxyDetailedAnyType<R, T1, T2, T3, T4, T5>;
template <typename R, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
using SignalProxyDetailed6 = SignalProxyDetailedAnyType<R, T1, T2, T3, T4, T5, T6>;
-
+
} // namespace Glib
#endif /* _GLIBMM_SIGNALPROXY_H */
-
diff --git a/glib/glibmm/signalproxy_connectionnode.h b/glib/glibmm/signalproxy_connectionnode.h
index b9deab0..1b226ed 100644
--- a/glib/glibmm/signalproxy_connectionnode.h
+++ b/glib/glibmm/signalproxy_connectionnode.h
@@ -26,7 +26,7 @@
#ifndef DOXYGEN_SHOULD_SKIP_THIS
typedef struct _GObject GObject;
typedef struct _GClosure GClosure;
-#endif //DOXYGEN_SHOULD_SKIP_THIS
+#endif // DOXYGEN_SHOULD_SKIP_THIS
namespace Glib
{
@@ -40,7 +40,6 @@ namespace Glib
class SignalProxyConnectionNode
{
public:
-
/** @param slot The signal handler for the glib signal.
* @param gobject The GObject that might emit this glib signal
*/
@@ -72,7 +71,7 @@ protected:
GObject* object_;
};
-#endif //DOXYGEN_SHOULD_SKIP_THIS
+#endif // DOXYGEN_SHOULD_SKIP_THIS
} /* namespace Glib */
diff --git a/glib/glibmm/slisthandle.h b/glib/glibmm/slisthandle.h
index af8f305..a952562 100644
--- a/glib/glibmm/slisthandle.h
+++ b/glib/glibmm/slisthandle.h
@@ -34,14 +34,15 @@ namespace Container_Helpers
* This requires bidirectional iterators.
*/
template <class Bi, class Tr>
-GSList* create_slist(Bi pbegin, Bi pend, Tr)
+GSList*
+create_slist(Bi pbegin, Bi pend, Tr)
{
GSList* head = nullptr;
- while(pend != pbegin)
+ while (pend != pbegin)
{
// Use & to force a warning if the iterator returns a temporary object.
- const void *const item = Tr::to_c_type(*&*--pend);
+ const void* const item = Tr::to_c_type(*&*--pend);
head = g_slist_prepend(head, const_cast<void*>(item));
}
@@ -53,14 +54,15 @@ GSList* create_slist(Bi pbegin, Bi pend, Tr)
* because appending to the list would be horribly inefficient.
*/
template <class For, class Tr>
-GSList* create_slist(For pbegin, Tr)
+GSList*
+create_slist(For pbegin, Tr)
{
GSList* head = nullptr;
- while(*pbegin)
+ while (*pbegin)
{
// Use & to force a warning if the iterator returns a temporary object.
- const void *const item = Tr::to_c_type(*&*pbegin);
+ const void* const item = Tr::to_c_type(*&*pbegin);
head = g_slist_prepend(head, const_cast<void*>(item));
++pbegin;
}
@@ -68,14 +70,15 @@ GSList* create_slist(For pbegin, Tr)
return g_slist_reverse(head);
}
-
/* Convert from any container that supports bidirectional iterators.
*/
template <class Tr, class Cont>
struct SListSourceTraits
{
static GSList* get_data(const Cont& cont)
- { return Glib::Container_Helpers::create_slist(cont.begin(), cont.end(), Tr()); }
+ {
+ return Glib::Container_Helpers::create_slist(cont.begin(), cont.end(), Tr());
+ }
static const Glib::OwnershipType initial_ownership = Glib::OWNERSHIP_SHALLOW;
};
@@ -84,38 +87,43 @@ struct SListSourceTraits
* argument must be a pointer to the first element.
*/
template <class Tr, class Cont>
-struct SListSourceTraits<Tr,Cont*>
+struct SListSourceTraits<Tr, Cont*>
{
static GSList* get_data(const Cont* array)
- { return (array) ? Glib::Container_Helpers::create_slist(array, Tr()) : nullptr; }
+ {
+ return (array) ? Glib::Container_Helpers::create_slist(array, Tr()) : nullptr;
+ }
static const Glib::OwnershipType initial_ownership = Glib::OWNERSHIP_SHALLOW;
};
template <class Tr, class Cont>
-struct SListSourceTraits<Tr,const Cont*> : SListSourceTraits<Tr,Cont*>
-{};
+struct SListSourceTraits<Tr, const Cont*> : SListSourceTraits<Tr, Cont*>
+{
+};
/* Convert from a 0-terminated array. The Cont argument must be a pointer
* to the first element. For consistency, the array must be 0-terminated,
* even though the array size is known at compile time.
*/
template <class Tr, class Cont, std::size_t N>
-struct SListSourceTraits<Tr,Cont[N]>
+struct SListSourceTraits<Tr, Cont[N]>
{
static GSList* get_data(const Cont* array)
- { return Glib::Container_Helpers::create_slist(array, array + (N - 1), Tr()); }
+ {
+ return Glib::Container_Helpers::create_slist(array, array + (N - 1), Tr());
+ }
static const Glib::OwnershipType initial_ownership = Glib::OWNERSHIP_SHALLOW;
};
template <class Tr, class Cont, std::size_t N>
-struct SListSourceTraits<Tr,const Cont[N]> : SListSourceTraits<Tr,Cont[N]>
-{};
+struct SListSourceTraits<Tr, const Cont[N]> : SListSourceTraits<Tr, Cont[N]>
+{
+};
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
/**
* @ingroup ContHelpers
*/
@@ -123,19 +131,19 @@ template <class Tr>
class SListHandleIterator
{
public:
- typedef typename Tr::CppType CppType;
- typedef typename Tr::CType CType;
+ typedef typename Tr::CppType CppType;
+ typedef typename Tr::CType CType;
- typedef std::forward_iterator_tag iterator_category;
- typedef CppType value_type;
- typedef std::ptrdiff_t difference_type;
- typedef value_type reference;
- typedef void pointer;
+ typedef std::forward_iterator_tag iterator_category;
+ typedef CppType value_type;
+ typedef std::ptrdiff_t difference_type;
+ typedef value_type reference;
+ typedef void pointer;
explicit inline SListHandleIterator(const GSList* node);
- inline value_type operator*() const;
- inline SListHandleIterator<Tr> & operator++();
+ inline value_type operator*() const;
+ inline SListHandleIterator<Tr>& operator++();
inline const SListHandleIterator<Tr> operator++(int);
inline bool operator==(const SListHandleIterator<Tr>& rhs) const;
@@ -147,8 +155,7 @@ private:
} // namespace Container_Helpers
-
-//TODO: Remove this when we can break glibmm API.
+// TODO: Remove this when we can break glibmm API.
/** This is an intermediate type. When a method takes this, or returns this, you
* should use a standard C++ container of your choice, such as std::list or
* std::vector.
@@ -157,56 +164,58 @@ private:
* which is less flexibile, but makes the API clearer.
* @ingroup ContHandles
*/
-template < class T, class Tr = Glib::Container_Helpers::TypeTraits<T> >
+template <class T, class Tr = Glib::Container_Helpers::TypeTraits<T>>
class SListHandle
{
public:
- typedef typename Tr::CppType CppType;
- typedef typename Tr::CType CType;
+ typedef typename Tr::CppType CppType;
+ typedef typename Tr::CType CType;
- typedef CppType value_type;
- typedef std::size_t size_type;
- typedef std::ptrdiff_t difference_type;
+ typedef CppType value_type;
+ typedef std::size_t size_type;
+ typedef std::ptrdiff_t difference_type;
- typedef Glib::Container_Helpers::SListHandleIterator<Tr> const_iterator;
- typedef Glib::Container_Helpers::SListHandleIterator<Tr> iterator;
+ typedef Glib::Container_Helpers::SListHandleIterator<Tr> const_iterator;
+ typedef Glib::Container_Helpers::SListHandleIterator<Tr> iterator;
- template <class Cont> inline
- SListHandle(const Cont& container);
+ template <class Cont>
+ inline SListHandle(const Cont& container);
// Take over ownership of a GSList created by GTK+ functions.
inline SListHandle(GSList* glist, Glib::OwnershipType ownership);
// Copying clears the ownership flag of the source handle.
- inline SListHandle(const SListHandle<T,Tr>& other);
+ inline SListHandle(const SListHandle<T, Tr>& other);
~SListHandle() noexcept;
inline const_iterator begin() const;
- inline const_iterator end() const;
+ inline const_iterator end() const;
- template <class U> inline operator std::vector<U>() const;
- template <class U> inline operator std::deque<U>() const;
- template <class U> inline operator std::list<U>() const;
+ template <class U>
+ inline operator std::vector<U>() const;
+ template <class U>
+ inline operator std::deque<U>() const;
+ template <class U>
+ inline operator std::list<U>() const;
- template <class Cont> inline
- void assign_to(Cont& container) const;
- template <class Out> inline
- void copy(Out pdest) const;
+ template <class Cont>
+ inline void assign_to(Cont& container) const;
+ template <class Out>
+ inline void copy(Out pdest) const;
- inline GSList* data() const;
- inline std::size_t size() const;
- inline bool empty() const;
+ inline GSList* data() const;
+ inline std::size_t size() const;
+ inline bool empty() const;
private:
- GSList * pslist_;
+ GSList* pslist_;
mutable Glib::OwnershipType ownership_;
// No copy assignment.
- SListHandle<T,Tr>& operator=(const SListHandle<T,Tr>&);
+ SListHandle<T, Tr>& operator=(const SListHandle<T, Tr>&);
};
-
/***************************************************************************/
/* Inline implementation */
/***************************************************************************/
@@ -218,106 +227,103 @@ namespace Container_Helpers
/**** Glib::Container_Helpers::SListHandleIterator<> ***********************/
-template <class Tr> inline
-SListHandleIterator<Tr>::SListHandleIterator(const GSList* node)
-:
- node_ (node)
-{}
+template <class Tr>
+inline SListHandleIterator<Tr>::SListHandleIterator(const GSList* node) : node_(node)
+{
+}
-template <class Tr> inline
-typename SListHandleIterator<Tr>::value_type SListHandleIterator<Tr>::operator*() const
+template <class Tr>
+inline typename SListHandleIterator<Tr>::value_type SListHandleIterator<Tr>::operator*() const
{
return Tr::to_cpp_type(static_cast<typename Tr::CTypeNonConst>(node_->data));
}
-template <class Tr> inline
-SListHandleIterator<Tr>& SListHandleIterator<Tr>::operator++()
+template <class Tr>
+inline SListHandleIterator<Tr>& SListHandleIterator<Tr>::operator++()
{
node_ = node_->next;
return *this;
}
-template <class Tr> inline
-const SListHandleIterator<Tr> SListHandleIterator<Tr>::operator++(int)
+template <class Tr>
+inline const SListHandleIterator<Tr> SListHandleIterator<Tr>::operator++(int)
{
- const SListHandleIterator<Tr> tmp (*this);
+ const SListHandleIterator<Tr> tmp(*this);
node_ = node_->next;
return tmp;
}
-template <class Tr> inline
-bool SListHandleIterator<Tr>::operator==(const SListHandleIterator<Tr>& rhs) const
+template <class Tr>
+inline bool
+SListHandleIterator<Tr>::operator==(const SListHandleIterator<Tr>& rhs) const
{
return (node_ == rhs.node_);
}
-template <class Tr> inline
-bool SListHandleIterator<Tr>::operator!=(const SListHandleIterator<Tr>& rhs) const
+template <class Tr>
+inline bool
+SListHandleIterator<Tr>::operator!=(const SListHandleIterator<Tr>& rhs) const
{
return (node_ != rhs.node_);
}
} // namespace Container_Helpers
-
/**** Glib::SListHandle<> **************************************************/
template <class T, class Tr>
- template <class Cont>
-inline
-SListHandle<T,Tr>::SListHandle(const Cont& container)
-:
- pslist_ (Glib::Container_Helpers::SListSourceTraits<Tr,Cont>::get_data(container)),
- ownership_ (Glib::Container_Helpers::SListSourceTraits<Tr,Cont>::initial_ownership)
-{}
-
-template <class T, class Tr> inline
-SListHandle<T,Tr>::SListHandle(GSList* gslist, Glib::OwnershipType ownership)
-:
- pslist_ (gslist),
- ownership_ (ownership)
-{}
-
-template <class T, class Tr> inline
-SListHandle<T,Tr>::SListHandle(const SListHandle<T,Tr>& other)
-:
- pslist_ (other.pslist_),
- ownership_ (other.ownership_)
+template <class Cont>
+inline SListHandle<T, Tr>::SListHandle(const Cont& container)
+: pslist_(Glib::Container_Helpers::SListSourceTraits<Tr, Cont>::get_data(container)),
+ ownership_(Glib::Container_Helpers::SListSourceTraits<Tr, Cont>::initial_ownership)
+{
+}
+
+template <class T, class Tr>
+inline SListHandle<T, Tr>::SListHandle(GSList* gslist, Glib::OwnershipType ownership)
+: pslist_(gslist), ownership_(ownership)
+{
+}
+
+template <class T, class Tr>
+inline SListHandle<T, Tr>::SListHandle(const SListHandle<T, Tr>& other)
+: pslist_(other.pslist_), ownership_(other.ownership_)
{
other.ownership_ = Glib::OWNERSHIP_NONE;
}
template <class T, class Tr>
-SListHandle<T,Tr>::~SListHandle() noexcept
+SListHandle<T, Tr>::~SListHandle() noexcept
{
- if(ownership_ != Glib::OWNERSHIP_NONE)
+ if (ownership_ != Glib::OWNERSHIP_NONE)
{
- if(ownership_ != Glib::OWNERSHIP_SHALLOW)
+ if (ownership_ != Glib::OWNERSHIP_SHALLOW)
{
// Deep ownership: release each container element.
- for(GSList* node = pslist_; node != nullptr; node = node->next)
+ for (GSList* node = pslist_; node != nullptr; node = node->next)
Tr::release_c_type(static_cast<typename Tr::CTypeNonConst>(node->data));
}
g_slist_free(pslist_);
}
}
-template <class T, class Tr> inline
-typename SListHandle<T,Tr>::const_iterator SListHandle<T,Tr>::begin() const
+template <class T, class Tr>
+inline typename SListHandle<T, Tr>::const_iterator
+SListHandle<T, Tr>::begin() const
{
return Glib::Container_Helpers::SListHandleIterator<Tr>(pslist_);
}
-template <class T, class Tr> inline
-typename SListHandle<T,Tr>::const_iterator SListHandle<T,Tr>::end() const
+template <class T, class Tr>
+inline typename SListHandle<T, Tr>::const_iterator
+SListHandle<T, Tr>::end() const
{
return Glib::Container_Helpers::SListHandleIterator<Tr>(nullptr);
}
template <class T, class Tr>
- template <class U>
-inline
-SListHandle<T,Tr>::operator std::vector<U>() const
+template <class U>
+inline SListHandle<T, Tr>::operator std::vector<U>() const
{
#ifdef GLIBMM_HAVE_TEMPLATE_SEQUENCE_CTORS
return std::vector<U>(this->begin(), this->end());
@@ -330,9 +336,8 @@ SListHandle<T,Tr>::operator std::vector<U>() const
}
template <class T, class Tr>
- template <class U>
-inline
-SListHandle<T,Tr>::operator std::deque<U>() const
+template <class U>
+inline SListHandle<T, Tr>::operator std::deque<U>() const
{
#ifdef GLIBMM_HAVE_TEMPLATE_SEQUENCE_CTORS
return std::deque<U>(this->begin(), this->end());
@@ -344,9 +349,8 @@ SListHandle<T,Tr>::operator std::deque<U>() const
}
template <class T, class Tr>
- template <class U>
-inline
-SListHandle<T,Tr>::operator std::list<U>() const
+template <class U>
+inline SListHandle<T, Tr>::operator std::list<U>() const
{
#ifdef GLIBMM_HAVE_TEMPLATE_SEQUENCE_CTORS
return std::list<U>(this->begin(), this->end());
@@ -358,9 +362,9 @@ SListHandle<T,Tr>::operator std::list<U>() const
}
template <class T, class Tr>
- template <class Cont>
-inline
-void SListHandle<T,Tr>::assign_to(Cont& container) const
+template <class Cont>
+inline void
+SListHandle<T, Tr>::assign_to(Cont& container) const
{
#ifdef GLIBMM_HAVE_TEMPLATE_SEQUENCE_CTORS
container.assign(this->begin(), this->end());
@@ -372,27 +376,30 @@ void SListHandle<T,Tr>::assign_to(Cont& container) const
}
template <class T, class Tr>
- template <class Out>
-inline
-void SListHandle<T,Tr>::copy(Out pdest) const
+template <class Out>
+inline void
+SListHandle<T, Tr>::copy(Out pdest) const
{
std::copy(this->begin(), this->end(), pdest);
}
-template <class T, class Tr> inline
-GSList* SListHandle<T,Tr>::data() const
+template <class T, class Tr>
+inline GSList*
+SListHandle<T, Tr>::data() const
{
return pslist_;
}
-template <class T, class Tr> inline
-std::size_t SListHandle<T,Tr>::size() const
+template <class T, class Tr>
+inline std::size_t
+SListHandle<T, Tr>::size() const
{
return g_slist_length(pslist_);
}
-template <class T, class Tr> inline
-bool SListHandle<T,Tr>::empty() const
+template <class T, class Tr>
+inline bool
+SListHandle<T, Tr>::empty() const
{
return (pslist_ == nullptr);
}
@@ -401,6 +408,4 @@ bool SListHandle<T,Tr>::empty() const
} // namespace Glib
-
#endif /* _GLIBMM_SLISTHANDLE_H */
-
diff --git a/glib/glibmm/streamiochannel.h b/glib/glibmm/streamiochannel.h
index bcadc87..0cf89af 100644
--- a/glib/glibmm/streamiochannel.h
+++ b/glib/glibmm/streamiochannel.h
@@ -29,7 +29,8 @@ namespace Glib
#ifndef GLIBMM_DISABLE_DEPRECATED
-/** @deprecated This whole class was deprecated in glibmm 2.2 - See the Glib::IOChannel documentation for an
explanation.
+/** @deprecated This whole class was deprecated in glibmm 2.2 - See the Glib::IOChannel
+ * documentation for an explanation.
*/
class StreamIOChannel : public Glib::IOChannel
{
diff --git a/glib/glibmm/stringutils.h b/glib/glibmm/stringutils.h
index 4e2fb0a..a81d770 100644
--- a/glib/glibmm/stringutils.h
+++ b/glib/glibmm/stringutils.h
@@ -23,7 +23,6 @@
#include <glibmm/ustring.h>
-
namespace Glib
{
@@ -49,7 +48,6 @@ bool str_has_prefix(const std::string& str, const std::string& prefix);
*/
bool str_has_suffix(const std::string& str, const std::string& suffix);
-
namespace Ascii
{
@@ -94,9 +92,8 @@ double strtod(const std::string& str);
* @throw std::overflow_error Thrown if the correct value would cause overflow.
* @throw std::underflow_error Thrown if the correct value would cause underflow.
*/
-double strtod(const std::string& str,
- std::string::size_type& end_index,
- std::string::size_type start_index = 0);
+double strtod(const std::string& str, std::string::size_type& end_index,
+ std::string::size_type start_index = 0);
/** Converts a <tt>double</tt> to a string, using the @c '.' as decimal point.
* @ingroup StringUtils
@@ -111,7 +108,6 @@ std::string dtostr(double d);
} // namespace Ascii
-
/** Escapes all special characters in the string.
* @ingroup StringUtils
* Escapes the special characters <tt>'\\b'</tt>, <tt>'\\f'</tt>, <tt>'\\n'</tt>,
@@ -179,6 +175,4 @@ Glib::ustring strsignal(int signum);
} // namespace Glib
-
#endif /* _GLIBMM_STRINGUTILS_H */
-
diff --git a/glib/glibmm/threadpool.h b/glib/glibmm/threadpool.h
index fbf4739..6bf4aec 100644
--- a/glib/glibmm/threadpool.h
+++ b/glib/glibmm/threadpool.h
@@ -24,8 +24,9 @@
#include <sigc++/sigc++.h>
-extern "C" { typedef struct _GThreadPool GThreadPool; }
-
+extern "C" {
+typedef struct _GThreadPool GThreadPool;
+}
namespace Glib
{
@@ -38,7 +39,7 @@ namespace Glib
* @{
*/
-//TODO: Is std::async() an appropriate replacement to mention for this deprecated API?
+// TODO: Is std::async() an appropriate replacement to mention for this deprecated API?
/** A pool of threads to execute work concurrently.
*
@@ -70,7 +71,7 @@ public:
explicit ThreadPool(int max_threads = -1, bool exclusive = false);
virtual ~ThreadPool() noexcept;
- //See http://bugzilla.gnome.org/show_bug.cgi?id=512348 about the sigc::trackable issue.
+ // See http://bugzilla.gnome.org/show_bug.cgi?id=512348 about the sigc::trackable issue.
// TODO: At the next ABI break, consider changing const sigc::slot<void>& slot
// to const std::function<void()>& func, if it can be assumed that all supported
// compilers understand the C++11 template class std::function<>.
@@ -165,7 +166,7 @@ public:
*/
static void stop_unused_threads();
- GThreadPool* gobj() { return gobject_; }
+ GThreadPool* gobj() { return gobject_; }
const GThreadPool* gobj() const { return gobject_; }
#ifndef DOXYGEN_SHOULD_SKIP_THIS
@@ -174,7 +175,7 @@ public:
private:
GThreadPool* gobject_;
- SlotList* slot_list_;
+ SlotList* slot_list_;
ThreadPool(const ThreadPool&);
ThreadPool& operator=(const ThreadPool&);
@@ -182,7 +183,6 @@ private:
/** @} group ThreadPools */
-
/***************************************************************************/
/* inline implementation */
/***************************************************************************/
@@ -191,7 +191,6 @@ private:
/**** Glib::Private ********************************************************/
-
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
} // namespace Glib
@@ -199,4 +198,3 @@ private:
#endif // GLIBMM_DISABLE_DEPRECATED
#endif /* _GLIBMM_THREADPOOL_H */
-
diff --git a/glib/glibmm/timer.h b/glib/glibmm/timer.h
index 9bd75e5..c99c602 100644
--- a/glib/glibmm/timer.h
+++ b/glib/glibmm/timer.h
@@ -23,8 +23,9 @@
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-extern "C" { typedef struct _GTimer GTimer; }
-
+extern "C" {
+typedef struct _GTimer GTimer;
+}
namespace Glib
{
@@ -61,7 +62,7 @@ public:
double elapsed(unsigned long& microseconds) const;
#ifndef DOXYGEN_SHOULD_SKIP_THIS
- GTimer* gobj() { return gobject_; }
+ GTimer* gobj() { return gobject_; }
const GTimer* gobj() const { return gobject_; }
#endif
@@ -69,11 +70,8 @@ private:
GTimer* gobject_;
};
-
void usleep(unsigned long microseconds);
} // namespace Glib
-
#endif /* _GLIBMM_TIMER_H */
-
diff --git a/glib/glibmm/timeval.h b/glib/glibmm/timeval.h
index 0e49dba..11b3c44 100644
--- a/glib/glibmm/timeval.h
+++ b/glib/glibmm/timeval.h
@@ -93,157 +93,152 @@ struct TimeVal : public GTimeVal
inline bool valid() const;
};
-inline
-TimeVal::TimeVal()
+inline TimeVal::TimeVal()
{
- tv_sec = 0;
+ tv_sec = 0;
tv_usec = 0;
}
-inline
-TimeVal::TimeVal(long seconds, long microseconds)
+inline TimeVal::TimeVal(long seconds, long microseconds)
{
- tv_sec = seconds;
+ tv_sec = seconds;
tv_usec = microseconds;
}
-inline
-TimeVal::TimeVal(const GTimeVal& gtimeval)
+inline TimeVal::TimeVal(const GTimeVal& gtimeval)
{
- tv_sec = gtimeval.tv_sec;
+ tv_sec = gtimeval.tv_sec;
tv_usec = gtimeval.tv_usec;
}
-inline
-TimeVal& TimeVal::operator=(const GTimeVal& gtimeval)
+inline TimeVal&
+TimeVal::operator=(const GTimeVal& gtimeval)
{
- tv_sec = gtimeval.tv_sec;
+ tv_sec = gtimeval.tv_sec;
tv_usec = gtimeval.tv_usec;
return *this;
}
-inline
-TimeVal& TimeVal::operator+=(const TimeVal& gtimeval)
+inline TimeVal&
+TimeVal::operator+=(const TimeVal& gtimeval)
{
add(gtimeval);
return *this;
}
-inline
-TimeVal& TimeVal::operator-=(const TimeVal& gtimeval)
+inline TimeVal&
+TimeVal::operator-=(const TimeVal& gtimeval)
{
subtract(gtimeval);
return *this;
}
-inline
-TimeVal& TimeVal::operator+=(long seconds)
+inline TimeVal&
+TimeVal::operator+=(long seconds)
{
add_seconds(seconds);
return *this;
}
-inline
-TimeVal& TimeVal::operator-=(long seconds)
+inline TimeVal&
+TimeVal::operator-=(long seconds)
{
subtract_seconds(seconds);
return *this;
}
-inline
-double TimeVal::as_double() const
+inline double
+TimeVal::as_double() const
{
return double(tv_sec) + double(tv_usec) / double(G_USEC_PER_SEC);
}
-inline
-bool TimeVal::negative() const
+inline bool
+TimeVal::negative() const
{
return (tv_sec < 0);
}
-inline
-bool TimeVal::valid() const
+inline bool
+TimeVal::valid() const
{
return (tv_usec >= 0 && tv_usec < G_USEC_PER_SEC);
}
/** @relates Glib::TimeVal */
-inline
-TimeVal operator+(const TimeVal& lhs, const TimeVal& rhs)
-{ return TimeVal(lhs) += rhs; }
+inline TimeVal
+operator+(const TimeVal& lhs, const TimeVal& rhs)
+{
+ return TimeVal(lhs) += rhs;
+}
/** @relates Glib::TimeVal */
-inline
-TimeVal operator+(const TimeVal& lhs, long seconds)
-{ return TimeVal(lhs) += seconds; }
+inline TimeVal
+operator+(const TimeVal& lhs, long seconds)
+{
+ return TimeVal(lhs) += seconds;
+}
/** @relates Glib::TimeVal */
-inline
-TimeVal operator-(const TimeVal& lhs, const TimeVal& rhs)
-{ return TimeVal(lhs) -= rhs; }
+inline TimeVal
+operator-(const TimeVal& lhs, const TimeVal& rhs)
+{
+ return TimeVal(lhs) -= rhs;
+}
/** @relates Glib::TimeVal */
-inline
-TimeVal operator-(const TimeVal& lhs, long seconds)
-{ return TimeVal(lhs) -= seconds; }
-
+inline TimeVal
+operator-(const TimeVal& lhs, long seconds)
+{
+ return TimeVal(lhs) -= seconds;
+}
/** @relates Glib::TimeVal */
-inline
-bool operator==(const TimeVal& lhs, const TimeVal& rhs)
+inline bool
+operator==(const TimeVal& lhs, const TimeVal& rhs)
{
return (lhs.tv_sec == rhs.tv_sec && lhs.tv_usec == rhs.tv_usec);
}
/** @relates Glib::TimeVal */
-inline
-bool operator!=(const TimeVal& lhs, const TimeVal& rhs)
+inline bool
+operator!=(const TimeVal& lhs, const TimeVal& rhs)
{
return (lhs.tv_sec != rhs.tv_sec || lhs.tv_usec != rhs.tv_usec);
}
/** @relates Glib::TimeVal */
-inline
-bool operator<(const TimeVal& lhs, const TimeVal& rhs)
+inline bool
+operator<(const TimeVal& lhs, const TimeVal& rhs)
{
- return ((lhs.tv_sec < rhs.tv_sec) ||
- (lhs.tv_sec == rhs.tv_sec && lhs.tv_usec < rhs.tv_usec));
+ return ((lhs.tv_sec < rhs.tv_sec) || (lhs.tv_sec == rhs.tv_sec && lhs.tv_usec < rhs.tv_usec));
}
/** @relates Glib::TimeVal */
-inline
-bool operator>(const TimeVal& lhs, const TimeVal& rhs)
+inline bool
+operator>(const TimeVal& lhs, const TimeVal& rhs)
{
- return ((lhs.tv_sec > rhs.tv_sec) ||
- (lhs.tv_sec == rhs.tv_sec && lhs.tv_usec > rhs.tv_usec));
+ return ((lhs.tv_sec > rhs.tv_sec) || (lhs.tv_sec == rhs.tv_sec && lhs.tv_usec > rhs.tv_usec));
}
/** @relates Glib::TimeVal */
-inline
-bool operator<=(const TimeVal& lhs, const TimeVal& rhs)
+inline bool
+operator<=(const TimeVal& lhs, const TimeVal& rhs)
{
- return ((lhs.tv_sec < rhs.tv_sec) ||
- (lhs.tv_sec == rhs.tv_sec && lhs.tv_usec <= rhs.tv_usec));
+ return ((lhs.tv_sec < rhs.tv_sec) || (lhs.tv_sec == rhs.tv_sec && lhs.tv_usec <= rhs.tv_usec));
}
/** @relates Glib::TimeVal */
-inline
-bool operator>=(const TimeVal& lhs, const TimeVal& rhs)
+inline bool
+operator>=(const TimeVal& lhs, const TimeVal& rhs)
{
- return ((lhs.tv_sec > rhs.tv_sec) ||
- (lhs.tv_sec == rhs.tv_sec && lhs.tv_usec >= rhs.tv_usec));
+ return ((lhs.tv_sec > rhs.tv_sec) || (lhs.tv_sec == rhs.tv_sec && lhs.tv_usec >= rhs.tv_usec));
}
} // namespace Glib
-
#endif /* _GLIBMM_TIMEVAL_H */
-
-
-
-
diff --git a/glib/glibmm/ustring.h b/glib/glibmm/ustring.h
index ccbb103..a207611 100644
--- a/glib/glibmm/ustring.h
+++ b/glib/glibmm/ustring.h
@@ -40,36 +40,35 @@ template <class T>
struct IteratorTraits
{
typedef typename T::iterator_category iterator_category;
- typedef typename T::value_type value_type;
- typedef typename T::difference_type difference_type;
- typedef typename T::pointer pointer;
- typedef typename T::reference reference;
+ typedef typename T::value_type value_type;
+ typedef typename T::difference_type difference_type;
+ typedef typename T::pointer pointer;
+ typedef typename T::reference reference;
};
template <class T>
struct IteratorTraits<T*>
{
typedef std::random_access_iterator_tag iterator_category;
- typedef T value_type;
- typedef std::ptrdiff_t difference_type;
- typedef T* pointer;
- typedef T& reference;
+ typedef T value_type;
+ typedef std::ptrdiff_t difference_type;
+ typedef T* pointer;
+ typedef T& reference;
};
template <class T>
struct IteratorTraits<const T*>
{
typedef std::random_access_iterator_tag iterator_category;
- typedef T value_type;
- typedef std::ptrdiff_t difference_type;
- typedef const T* pointer;
- typedef const T& reference;
+ typedef T value_type;
+ typedef std::ptrdiff_t difference_type;
+ typedef const T* pointer;
+ typedef const T& reference;
};
#endif /* GLIBMM_HAVE_STD_ITERATOR_TRAITS */
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
/** The iterator type of Glib::ustring.
* Note this is not a random access iterator but a bidirectional one,
* since all index operations need to iterate over the UTF-8 data. Use
@@ -100,20 +99,20 @@ template <class T>
class ustring_Iterator
{
public:
- typedef std::bidirectional_iterator_tag iterator_category;
- typedef gunichar value_type;
- typedef std::string::difference_type difference_type;
- typedef value_type reference;
- typedef void pointer;
+ typedef std::bidirectional_iterator_tag iterator_category;
+ typedef gunichar value_type;
+ typedef std::string::difference_type difference_type;
+ typedef value_type reference;
+ typedef void pointer;
inline ustring_Iterator();
inline ustring_Iterator(const ustring_Iterator<std::string::iterator>& other);
inline value_type operator*() const;
- inline ustring_Iterator<T> & operator++();
+ inline ustring_Iterator<T>& operator++();
inline const ustring_Iterator<T> operator++(int);
- inline ustring_Iterator<T> & operator--();
+ inline ustring_Iterator<T>& operator--();
inline const ustring_Iterator<T> operator--(int);
explicit inline ustring_Iterator(T pos);
@@ -123,7 +122,6 @@ private:
T pos_;
};
-
/** Extract a UCS-4 character from UTF-8 data.
* Convert a single UTF-8 (multibyte) character starting at @p pos to
* a UCS-4 wide character. This may read up to 6 bytes after the start
@@ -136,7 +134,6 @@ private:
*/
gunichar get_unichar_from_std_iterator(std::string::const_iterator pos) G_GNUC_PURE;
-
/** Glib::ustring has much the same interface as std::string, but contains
* %Unicode characters encoded as UTF-8.
*
@@ -217,43 +214,38 @@ gunichar get_unichar_from_std_iterator(std::string::const_iterator pos) G_GNUC_P
class ustring
{
public:
- typedef std::string::size_type size_type;
- typedef std::string::difference_type difference_type;
+ typedef std::string::size_type size_type;
+ typedef std::string::difference_type difference_type;
- typedef gunichar value_type;
- typedef gunichar & reference;
- typedef const gunichar & const_reference;
+ typedef gunichar value_type;
+ typedef gunichar& reference;
+ typedef const gunichar& const_reference;
- typedef ustring_Iterator<std::string::iterator> iterator;
+ typedef ustring_Iterator<std::string::iterator> iterator;
typedef ustring_Iterator<std::string::const_iterator> const_iterator;
#ifndef GLIBMM_HAVE_SUN_REVERSE_ITERATOR
- typedef std::reverse_iterator<iterator> reverse_iterator;
- typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+ typedef std::reverse_iterator<iterator> reverse_iterator;
+ typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
#else
- typedef std::reverse_iterator<iterator,
- iterator::iterator_category,
- iterator::value_type,
- iterator::reference,
- iterator::pointer,
- iterator::difference_type> reverse_iterator;
- typedef std::reverse_iterator<const_iterator,
- const_iterator::iterator_category,
- const_iterator::value_type,
- const_iterator::reference,
- const_iterator::pointer,
- const_iterator::difference_type> const_reverse_iterator;
+ typedef std::reverse_iterator<iterator, iterator::iterator_category, iterator::value_type,
+ iterator::reference, iterator::pointer, iterator::difference_type>
+ reverse_iterator;
+ typedef std::reverse_iterator<const_iterator, const_iterator::iterator_category,
+ const_iterator::value_type, const_iterator::reference, const_iterator::pointer,
+ const_iterator::difference_type>
+ const_reverse_iterator;
#endif /* GLIBMM_HAVE_SUN_REVERSE_ITERATOR */
#ifdef GLIBMM_HAVE_ALLOWS_STATIC_INLINE_NPOS
static GLIBMM_API const size_type npos = std::string::npos;
#else
- //The IRIX MipsPro compiler says "The indicated constant value is not known",
- //so we need to initalize the static member data elsewhere.
+ // The IRIX MipsPro compiler says "The indicated constant value is not known",
+ // so we need to initalize the static member data elsewhere.
static GLIBMM_API const size_type npos;
#endif
@@ -303,7 +295,7 @@ public:
* @param i Index of first character to copy from.
* @param n Number of UTF-8 characters to copy (defaults to copying the remainder).
*/
- ustring(const ustring& src, size_type i, size_type n=npos);
+ ustring(const ustring& src, size_type i, size_type n = npos);
/*! Construct a ustring as a partial copy of a C string.
* @param src %Source C string encoded as UTF-8.
@@ -332,11 +324,11 @@ public:
* @param pbegin Start of range.
* @param pend End of range.
*/
- template <class In> ustring(In pbegin, In pend);
+ template <class In>
+ ustring(In pbegin, In pend);
-
-//! @name Assign new contents.
-//! @{
+ //! @name Assign new contents.
+ //! @{
ustring& operator=(const std::string& src);
ustring& operator=(std::string&& src);
@@ -351,11 +343,12 @@ public:
ustring& assign(const char* src);
ustring& assign(size_type n, gunichar uc);
ustring& assign(size_type n, char c);
- template <class In> ustring& assign(In pbegin, In pend);
+ template <class In>
+ ustring& assign(In pbegin, In pend);
-//! @}
-//! @name Append to the string.
-//! @{
+ //! @}
+ //! @name Append to the string.
+ //! @{
ustring& operator+=(const ustring& src);
ustring& operator+=(const char* src);
@@ -370,11 +363,12 @@ public:
ustring& append(const char* src);
ustring& append(size_type n, gunichar uc);
ustring& append(size_type n, char c);
- template <class In> ustring& append(In pbegin, In pend);
+ template <class In>
+ ustring& append(In pbegin, In pend);
-//! @}
-//! @name Insert into the string.
-//! @{
+ //! @}
+ //! @name Insert into the string.
+ //! @{
ustring& insert(size_type i, const ustring& src);
ustring& insert(size_type i, const ustring& src, size_type i2, size_type n);
@@ -385,13 +379,14 @@ public:
iterator insert(iterator p, gunichar uc);
iterator insert(iterator p, char c);
- void insert(iterator p, size_type n, gunichar uc);
- void insert(iterator p, size_type n, char c);
- template <class In> void insert(iterator p, In pbegin, In pend);
+ void insert(iterator p, size_type n, gunichar uc);
+ void insert(iterator p, size_type n, char c);
+ template <class In>
+ void insert(iterator p, In pbegin, In pend);
-//! @}
-//! @name Replace sub-strings.
-//! @{
+ //! @}
+ //! @name Replace sub-strings.
+ //! @{
ustring& replace(size_type i, size_type n, const ustring& src);
ustring& replace(size_type i, size_type n, const ustring& src, size_type i2, size_type n2);
@@ -405,24 +400,25 @@ public:
ustring& replace(iterator pbegin, iterator pend, const char* src);
ustring& replace(iterator pbegin, iterator pend, size_type n, gunichar uc);
ustring& replace(iterator pbegin, iterator pend, size_type n, char c);
- template <class In> ustring& replace(iterator pbegin, iterator pend, In pbegin2, In pend2);
+ template <class In>
+ ustring& replace(iterator pbegin, iterator pend, In pbegin2, In pend2);
-//! @}
-//! @name Erase sub-strings.
-//! @{
+ //! @}
+ //! @name Erase sub-strings.
+ //! @{
void clear();
- ustring& erase(size_type i, size_type n=npos);
+ ustring& erase(size_type i, size_type n = npos);
ustring& erase();
iterator erase(iterator p);
iterator erase(iterator pbegin, iterator pend);
-//! @}
-//! @name Compare and collate.
-//! @{
+ //! @}
+ //! @name Compare and collate.
+ //! @{
int compare(const ustring& rhs) const;
- int compare(const char* rhs) const;
+ int compare(const char* rhs) const;
int compare(size_type i, size_type n, const ustring& rhs) const;
int compare(size_type i, size_type n, const ustring& rhs, size_type i2, size_type n2) const;
int compare(size_type i, size_type n, const char* rhs, size_type n2) const;
@@ -448,9 +444,9 @@ public:
*/
std::string casefold_collate_key() const;
-//! @}
-//! @name Extract characters and sub-strings.
-//! @{
+ //! @}
+ //! @name Extract characters and sub-strings.
+ //! @{
/*! No reference return; use replace() to write characters. */
value_type operator[](size_type i) const;
@@ -458,82 +454,82 @@ public:
/*! No reference return; use replace() to write characters. @throw std::out_of_range */
value_type at(size_type i) const;
- inline ustring substr(size_type i=0, size_type n=npos) const;
+ inline ustring substr(size_type i = 0, size_type n = npos) const;
-//! @}
-//! @name Access a sequence of characters.
-//! @{
+ //! @}
+ //! @name Access a sequence of characters.
+ //! @{
iterator begin();
iterator end();
const_iterator begin() const;
- const_iterator end() const;
+ const_iterator end() const;
reverse_iterator rbegin();
reverse_iterator rend();
const_reverse_iterator rbegin() const;
- const_reverse_iterator rend() const;
+ const_reverse_iterator rend() const;
-//! @}
-//! @name Find sub-strings.
-//! @{
+ //! @}
+ //! @name Find sub-strings.
+ //! @{
- size_type find(const ustring& str, size_type i=0) const;
+ size_type find(const ustring& str, size_type i = 0) const;
size_type find(const char* str, size_type i, size_type n) const;
- size_type find(const char* str, size_type i=0) const;
- size_type find(gunichar uc, size_type i=0) const;
- size_type find(char c, size_type i=0) const;
+ size_type find(const char* str, size_type i = 0) const;
+ size_type find(gunichar uc, size_type i = 0) const;
+ size_type find(char c, size_type i = 0) const;
- size_type rfind(const ustring& str, size_type i=npos) const;
+ size_type rfind(const ustring& str, size_type i = npos) const;
size_type rfind(const char* str, size_type i, size_type n) const;
- size_type rfind(const char* str, size_type i=npos) const;
- size_type rfind(gunichar uc, size_type i=npos) const;
- size_type rfind(char c, size_type i=npos) const;
+ size_type rfind(const char* str, size_type i = npos) const;
+ size_type rfind(gunichar uc, size_type i = npos) const;
+ size_type rfind(char c, size_type i = npos) const;
-//! @}
-//! @name Match against a set of characters.
-//! @{
+ //! @}
+ //! @name Match against a set of characters.
+ //! @{
- size_type find_first_of(const ustring& match, size_type i=0) const;
+ size_type find_first_of(const ustring& match, size_type i = 0) const;
size_type find_first_of(const char* match, size_type i, size_type n) const;
- size_type find_first_of(const char* match, size_type i=0) const;
- size_type find_first_of(gunichar uc, size_type i=0) const;
- size_type find_first_of(char c, size_type i=0) const;
+ size_type find_first_of(const char* match, size_type i = 0) const;
+ size_type find_first_of(gunichar uc, size_type i = 0) const;
+ size_type find_first_of(char c, size_type i = 0) const;
- size_type find_last_of(const ustring& match, size_type i=npos) const;
+ size_type find_last_of(const ustring& match, size_type i = npos) const;
size_type find_last_of(const char* match, size_type i, size_type n) const;
- size_type find_last_of(const char* match, size_type i=npos) const;
- size_type find_last_of(gunichar uc, size_type i=npos) const;
- size_type find_last_of(char c, size_type i=npos) const;
+ size_type find_last_of(const char* match, size_type i = npos) const;
+ size_type find_last_of(gunichar uc, size_type i = npos) const;
+ size_type find_last_of(char c, size_type i = npos) const;
- size_type find_first_not_of(const ustring& match, size_type i=0) const;
+ size_type find_first_not_of(const ustring& match, size_type i = 0) const;
size_type find_first_not_of(const char* match, size_type i, size_type n) const;
- size_type find_first_not_of(const char* match, size_type i=0) const;
- size_type find_first_not_of(gunichar uc, size_type i=0) const;
- size_type find_first_not_of(char c, size_type i=0) const;
+ size_type find_first_not_of(const char* match, size_type i = 0) const;
+ size_type find_first_not_of(gunichar uc, size_type i = 0) const;
+ size_type find_first_not_of(char c, size_type i = 0) const;
- size_type find_last_not_of(const ustring& match, size_type i=npos) const;
+ size_type find_last_not_of(const ustring& match, size_type i = npos) const;
size_type find_last_not_of(const char* match, size_type i, size_type n) const;
- size_type find_last_not_of(const char* match, size_type i=npos) const;
- size_type find_last_not_of(gunichar uc, size_type i=npos) const;
- size_type find_last_not_of(char c, size_type i=npos) const;
+ size_type find_last_not_of(const char* match, size_type i = npos) const;
+ size_type find_last_not_of(gunichar uc, size_type i = npos) const;
+ size_type find_last_not_of(char c, size_type i = npos) const;
-//! @}
-//! @name Retrieve the string's size.
-//! @{
+ //! @}
+ //! @name Retrieve the string's size.
+ //! @{
/** Returns true if the string is empty. Equivalent to *this == "".
* @result Whether the string is empty.
*/
- bool empty() const;
+ bool empty() const;
/** Returns the number of characters in the string, not including any null-termination.
* @result The number of UTF-8 characters.
*
* @see bytes(), empty()
*/
- size_type size() const;
+ size_type size() const;
- //We have length() as well as size(), because std::string has both.
+ // We have length() as well as size(), because std::string has both.
/** This is the same as size().
*/
@@ -544,40 +540,40 @@ public:
*
* @see size(), empty()
*/
- size_type bytes() const;
+ size_type bytes() const;
-//! @}
-//! @name Change the string's size.
-//! @{
+ //! @}
+ //! @name Change the string's size.
+ //! @{
void resize(size_type n, gunichar uc);
- void resize(size_type n, char c='\0');
+ void resize(size_type n, char c = '\0');
-//! @}
-//! @name Control the allocated memory.
-//! @{
+ //! @}
+ //! @name Control the allocated memory.
+ //! @{
size_type capacity() const;
size_type max_size() const;
- void reserve(size_type n=0);
+ void reserve(size_type n = 0);
-//! @}
-//! @name Get a per-byte representation of the string.
-//! @{
+ //! @}
+ //! @name Get a per-byte representation of the string.
+ //! @{
inline operator std::string() const; // e.g. std::string str = ustring();
inline const std::string& raw() const;
// Not necessarily an ASCII char*. Use g_utf8_*() where necessary.
- const char* data() const;
+ const char* data() const;
const char* c_str() const;
/*! @return Number of copied @em bytes, not characters. */
- size_type copy(char* dest, size_type n, size_type i=0) const;
+ size_type copy(char* dest, size_type n, size_type i = 0) const;
-//! @}
-//! @name UTF-8 utilities.
-//! @{
+ //! @}
+ //! @name UTF-8 utilities.
+ //! @{
/*! Check whether the string is valid UTF-8. */
bool validate() const;
@@ -599,9 +595,9 @@ public:
/*! "Normalize" the %Unicode character representation of the string. */
ustring normalize(NormalizeMode mode = NORMALIZE_DEFAULT_COMPOSE) const;
-//! @}
-//! @name Character case conversion.
-//! @{
+ //! @}
+ //! @name Character case conversion.
+ //! @{
/*! Returns a new UTF-8 string with all characters characters converted to
* their uppercase equivalent, while honoring the current locale. The
@@ -626,16 +622,15 @@ public:
*/
ustring casefold() const;
-//! @}
-//! @name Message formatting.
-//! @{
+ //! @}
+ //! @name Message formatting.
+ //! @{
/* Returns fmt as is, but checks for invalid references in the format string.
* @newin{2,18}
*/
template <class T1>
- static inline
- ustring compose(const ustring& fmt);
+ static inline ustring compose(const ustring& fmt);
/*! Substitute placeholders in a format string with the referenced arguments.
* The template string should be in <tt>qt-format</tt>, that is
@@ -656,82 +651,62 @@ public:
* @newin{2,16}
*/
template <class T1>
- static inline
- ustring compose(const ustring& fmt, const T1& a1);
+ static inline ustring compose(const ustring& fmt, const T1& a1);
/* See the documentation for compose(const ustring& fmt, const T1& a1).
* @newin{2,16}
*/
template <class T1, class T2>
- static inline
- ustring compose(const ustring& fmt, const T1& a1, const T2& a2);
+ static inline ustring compose(const ustring& fmt, const T1& a1, const T2& a2);
/* See the documentation for compose(const ustring& fmt, const T1& a1).
* @newin{2,16}
*/
template <class T1, class T2, class T3>
- static inline
- ustring compose(const ustring& fmt,
- const T1& a1, const T2& a2, const T3& a3);
+ static inline ustring compose(const ustring& fmt, const T1& a1, const T2& a2, const T3& a3);
/* See the documentation for compose(const ustring& fmt, const T1& a1).
* @newin{2,16}
*/
template <class T1, class T2, class T3, class T4>
- static inline
- ustring compose(const ustring& fmt,
- const T1& a1, const T2& a2, const T3& a3,
- const T4& a4);
+ static inline ustring compose(
+ const ustring& fmt, const T1& a1, const T2& a2, const T3& a3, const T4& a4);
/* See the documentation for compose(const ustring& fmt, const T1& a1).
* @newin{2,16}
*/
template <class T1, class T2, class T3, class T4, class T5>
- static inline
- ustring compose(const ustring& fmt,
- const T1& a1, const T2& a2, const T3& a3,
- const T4& a4, const T5& a5);
+ static inline ustring compose(
+ const ustring& fmt, const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5);
/* See the documentation for compose(const ustring& fmt, const T1& a1).
* @newin{2,16}
*/
template <class T1, class T2, class T3, class T4, class T5, class T6>
- static inline
- ustring compose(const ustring& fmt,
- const T1& a1, const T2& a2, const T3& a3,
- const T4& a4, const T5& a5, const T6& a6);
+ static inline ustring compose(const ustring& fmt, const T1& a1, const T2& a2, const T3& a3,
+ const T4& a4, const T5& a5, const T6& a6);
/* See the documentation for compose(const ustring& fmt, const T1& a1).
* @newin{2,16}
*/
template <class T1, class T2, class T3, class T4, class T5, class T6, class T7>
- static inline
- ustring compose(const ustring& fmt,
- const T1& a1, const T2& a2, const T3& a3,
- const T4& a4, const T5& a5, const T6& a6,
- const T7& a7);
+ static inline ustring compose(const ustring& fmt, const T1& a1, const T2& a2, const T3& a3,
+ const T4& a4, const T5& a5, const T6& a6, const T7& a7);
/* See the documentation for compose(const ustring& fmt, const T1& a1).
* @newin{2,16}
*/
- template <class T1, class T2, class T3, class T4,
- class T5, class T6, class T7, class T8>
- static inline
- ustring compose(const ustring& fmt,
- const T1& a1, const T2& a2, const T3& a3,
- const T4& a4, const T5& a5, const T6& a6,
- const T7& a7, const T8& a8);
+ template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
+ static inline ustring compose(const ustring& fmt, const T1& a1, const T2& a2, const T3& a3,
+ const T4& a4, const T5& a5, const T6& a6, const T7& a7, const T8& a8);
/* See the documentation for compose(const ustring& fmt, const T1& a1).
* @newin{2,16}
*/
- template <class T1, class T2, class T3, class T4, class T5,
- class T6, class T7, class T8, class T9>
- static inline
- ustring compose(const ustring& fmt,
- const T1& a1, const T2& a2, const T3& a3,
- const T4& a4, const T5& a5, const T6& a6,
- const T7& a7, const T8& a8, const T9& a9);
+ template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8,
+ class T9>
+ static inline ustring compose(const ustring& fmt, const T1& a1, const T2& a2, const T3& a3,
+ const T4& a4, const T5& a5, const T6& a6, const T7& a7, const T8& a8, const T9& a9);
/*! Format the argument to its string representation.
* Applies the arguments in order to an std::wostringstream and returns the
@@ -764,74 +739,63 @@ public:
* @newin{2,16}
*/
template <class T1>
- static inline
- ustring format(const T1& a1);
+ static inline ustring format(const T1& a1);
/* See the documentation for format(const T1& a1).
*
* @newin{2,16}
*/
template <class T1, class T2>
- static inline
- ustring format(const T1& a1, const T2& a2);
+ static inline ustring format(const T1& a1, const T2& a2);
/* See the documentation for format(const T1& a1).
*
* @newin{2,16}
*/
template <class T1, class T2, class T3>
- static inline
- ustring format(const T1& a1, const T2& a2, const T3& a3);
+ static inline ustring format(const T1& a1, const T2& a2, const T3& a3);
/* See the documentation for format(const T1& a1).
*
* @newin{2,16}
*/
template <class T1, class T2, class T3, class T4>
- static inline
- ustring format(const T1& a1, const T2& a2, const T3& a3, const T4& a4);
+ static inline ustring format(const T1& a1, const T2& a2, const T3& a3, const T4& a4);
/* See the documentation for format(const T1& a1).
*
* @newin{2,16}
*/
template <class T1, class T2, class T3, class T4, class T5>
- static inline
- ustring format(const T1& a1, const T2& a2, const T3& a3,
- const T4& a4, const T5& a5);
+ static inline ustring format(
+ const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5);
/* See the documentation for format(const T1& a1).
*
* @newin{2,16}
*/
template <class T1, class T2, class T3, class T4, class T5, class T6>
- static inline
- ustring format(const T1& a1, const T2& a2, const T3& a3,
- const T4& a4, const T5& a5, const T6& a6);
+ static inline ustring format(
+ const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5, const T6& a6);
/* See the documentation for format(const T1& a1).
*
* @newin{2,16}
*/
- template <class T1, class T2, class T3, class T4,
- class T5, class T6, class T7>
- static inline
- ustring format(const T1& a1, const T2& a2, const T3& a3, const T4& a4,
- const T5& a5, const T6& a6, const T7& a7);
+ template <class T1, class T2, class T3, class T4, class T5, class T6, class T7>
+ static inline ustring format(const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5,
+ const T6& a6, const T7& a7);
/* See the documentation for format(const T1& a1).
*
* @newin{2,16}
*/
- template <class T1, class T2, class T3, class T4,
- class T5, class T6, class T7, class T8>
- static inline
- ustring format(const T1& a1, const T2& a2, const T3& a3, const T4& a4,
- const T5& a5, const T6& a6, const T7& a7, const T8& a8);
-//! @}
+ template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
+ static inline ustring format(const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5,
+ const T6& a6, const T7& a7, const T8& a8);
+ //! @}
private:
-
#ifndef DOXYGEN_SHOULD_SKIP_THIS
#ifdef GLIBMM_HAVE_STD_ITERATOR_TRAITS
@@ -841,12 +805,15 @@ private:
#endif
struct SequenceToString;
- //The Tru64 compiler needs these partial specializations to be declared here,
- //as well as defined later. That's probably correct. murrayc.
- template <class In> struct SequenceToString<In, char>;
- template <class In> struct SequenceToString<In, gunichar>;
+ // The Tru64 compiler needs these partial specializations to be declared here,
+ // as well as defined later. That's probably correct. murrayc.
+ template <class In>
+ struct SequenceToString<In, char>;
+ template <class In>
+ struct SequenceToString<In, gunichar>;
- template <class T> class Stringify;
+ template <class T>
+ class Stringify;
class FormatStream;
static ustring compose_argv(const ustring& fmt, int argc, const ustring* const* argv);
@@ -856,12 +823,12 @@ private:
std::string string_;
};
-
#ifndef DOXYGEN_SHOULD_SKIP_THIS
template <class In, class ValueType>
struct ustring::SequenceToString
-{};
+{
+};
template <class In>
struct ustring::SequenceToString<In, char> : public std::string
@@ -890,7 +857,6 @@ struct ustring::SequenceToString<Glib::ustring::const_iterator, gunichar> : publ
class ustring::FormatStream
{
public:
-
// noncopyable
FormatStream(const ustring::FormatStream&) = delete;
FormatStream& operator=(const ustring::FormatStream&) = delete;
@@ -907,11 +873,12 @@ public:
FormatStream();
~FormatStream() noexcept;
- template <class T> inline void stream(const T& value);
+ template <class T>
+ inline void stream(const T& value);
inline void stream(const char* value);
- //This overload exists to avoid the templated stream() being called for non-const char*.
+ // This overload exists to avoid the templated stream() being called for non-const char*.
inline void stream(char* value);
ustring to_string() const;
@@ -919,7 +886,6 @@ public:
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
/** Stream input operator.
* @relates Glib::ustring
* @throw Glib::ConvertError
@@ -956,129 +922,126 @@ std::wostream& operator<<(std::wostream& os, const ustring& utf8_string);
/**** Glib::ustring_Iterator<> *********************************************/
-template <class T> inline
-ustring_Iterator<T>::ustring_Iterator(T pos)
-:
- pos_ (pos)
-{}
+template <class T>
+inline ustring_Iterator<T>::ustring_Iterator(T pos) : pos_(pos)
+{
+}
-template <class T> inline
-T ustring_Iterator<T>::base() const
+template <class T>
+inline T
+ustring_Iterator<T>::base() const
{
return pos_;
}
-template <class T> inline
-ustring_Iterator<T>::ustring_Iterator()
-:
- pos_ ()
-{}
+template <class T>
+inline ustring_Iterator<T>::ustring_Iterator() : pos_()
+{
+}
-template <class T> inline
-ustring_Iterator<T>::ustring_Iterator(const ustring_Iterator<std::string::iterator>& other)
-:
- pos_ (other.base())
-{}
+template <class T>
+inline ustring_Iterator<T>::ustring_Iterator(const ustring_Iterator<std::string::iterator>& other)
+: pos_(other.base())
+{
+}
-template <class T> inline
-typename ustring_Iterator<T>::value_type ustring_Iterator<T>::operator*() const
+template <class T>
+inline typename ustring_Iterator<T>::value_type ustring_Iterator<T>::operator*() const
{
return Glib::get_unichar_from_std_iterator(pos_);
}
-template <class T> inline
-ustring_Iterator<T>& ustring_Iterator<T>::operator++()
+template <class T>
+inline ustring_Iterator<T>& ustring_Iterator<T>::operator++()
{
pos_ += g_utf8_skip[static_cast<unsigned char>(*pos_)];
return *this;
}
-template <class T> inline
-const ustring_Iterator<T> ustring_Iterator<T>::operator++(int)
+template <class T>
+inline const ustring_Iterator<T> ustring_Iterator<T>::operator++(int)
{
- const ustring_Iterator<T> temp (*this);
+ const ustring_Iterator<T> temp(*this);
this->operator++();
return temp;
}
-template <class T> inline
-ustring_Iterator<T>& ustring_Iterator<T>::operator--()
+template <class T>
+inline ustring_Iterator<T>& ustring_Iterator<T>::operator--()
{
while ((static_cast<unsigned char>(*--pos_) & 0xC0u) == 0x80)
;
return *this;
}
-template <class T> inline
-const ustring_Iterator<T> ustring_Iterator<T>::operator--(int)
+template <class T>
+inline const ustring_Iterator<T> ustring_Iterator<T>::operator--(int)
{
- const ustring_Iterator<T> temp (*this);
+ const ustring_Iterator<T> temp(*this);
this->operator--();
return temp;
}
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
/** @relates Glib::ustring_Iterator */
-inline
-bool operator==(const Glib::ustring::const_iterator& lhs, const Glib::ustring::const_iterator& rhs)
+inline bool
+operator==(const Glib::ustring::const_iterator& lhs, const Glib::ustring::const_iterator& rhs)
{
return (lhs.base() == rhs.base());
}
/** @relates Glib::ustring_Iterator */
-inline
-bool operator!=(const Glib::ustring::const_iterator& lhs, const Glib::ustring::const_iterator& rhs)
+inline bool
+operator!=(const Glib::ustring::const_iterator& lhs, const Glib::ustring::const_iterator& rhs)
{
return (lhs.base() != rhs.base());
}
/** @relates Glib::ustring_Iterator */
-inline
-bool operator<(const Glib::ustring::const_iterator& lhs, const Glib::ustring::const_iterator& rhs)
+inline bool
+operator<(const Glib::ustring::const_iterator& lhs, const Glib::ustring::const_iterator& rhs)
{
return (lhs.base() < rhs.base());
}
/** @relates Glib::ustring_Iterator */
-inline
-bool operator>(const Glib::ustring::const_iterator& lhs, const Glib::ustring::const_iterator& rhs)
+inline bool
+operator>(const Glib::ustring::const_iterator& lhs, const Glib::ustring::const_iterator& rhs)
{
return (lhs.base() > rhs.base());
}
/** @relates Glib::ustring_Iterator */
-inline
-bool operator<=(const Glib::ustring::const_iterator& lhs, const Glib::ustring::const_iterator& rhs)
+inline bool
+operator<=(const Glib::ustring::const_iterator& lhs, const Glib::ustring::const_iterator& rhs)
{
return (lhs.base() <= rhs.base());
}
/** @relates Glib::ustring_Iterator */
-inline
-bool operator>=(const Glib::ustring::const_iterator& lhs, const Glib::ustring::const_iterator& rhs)
+inline bool
+operator>=(const Glib::ustring::const_iterator& lhs, const Glib::ustring::const_iterator& rhs)
{
return (lhs.base() >= rhs.base());
}
-
#ifndef DOXYGEN_SHOULD_SKIP_THIS
/**** Glib::ustring::SequenceToString **************************************/
template <class In>
-ustring::SequenceToString<In,char>::SequenceToString(In pbegin, In pend)
-:
- std::string(pbegin, pend)
-{}
+ustring::SequenceToString<In, char>::SequenceToString(In pbegin, In pend)
+: std::string(pbegin, pend)
+{
+}
template <class In>
-ustring::SequenceToString<In,gunichar>::SequenceToString(In pbegin, In pend)
+ustring::SequenceToString<In, gunichar>::SequenceToString(In pbegin, In pend)
{
char utf8_buf[6]; // stores a single UTF-8 character
- for(; pbegin != pend; ++pbegin)
+ for (; pbegin != pend; ++pbegin)
{
const std::string::size_type utf8_len = g_unichar_to_utf8(*pbegin, utf8_buf);
this->append(utf8_buf, utf8_len);
@@ -1087,20 +1050,21 @@ ustring::SequenceToString<In,gunichar>::SequenceToString(In pbegin, In pend)
/**** Glib::ustring::FormatStream ******************************************/
-template <class T> inline
-void ustring::FormatStream::stream(const T& value)
+template <class T>
+inline void
+ustring::FormatStream::stream(const T& value)
{
stream_ << value;
}
-inline
-void ustring::FormatStream::stream(const char* value)
+inline void
+ustring::FormatStream::stream(const char* value)
{
stream_ << ustring(value);
}
-inline
-void ustring::FormatStream::stream(char* value)
+inline void
+ustring::FormatStream::stream(char* value)
{
stream_ << ustring(value);
}
@@ -1108,65 +1072,66 @@ void ustring::FormatStream::stream(char* value)
/**** Glib::ustring ********************************************************/
template <class In>
-ustring::ustring(In pbegin, In pend)
-:
- string_ (Glib::ustring::SequenceToString<In>(pbegin, pend))
-{}
+ustring::ustring(In pbegin, In pend) : string_(Glib::ustring::SequenceToString<In>(pbegin, pend))
+{
+}
template <class In>
-ustring& ustring::assign(In pbegin, In pend)
+ustring&
+ustring::assign(In pbegin, In pend)
{
- Glib::ustring::SequenceToString<In> temp_string (pbegin, pend);
+ Glib::ustring::SequenceToString<In> temp_string(pbegin, pend);
string_.swap(temp_string); // constant-time operation
return *this;
}
template <class In>
-ustring& ustring::append(In pbegin, In pend)
+ustring&
+ustring::append(In pbegin, In pend)
{
string_.append(Glib::ustring::SequenceToString<In>(pbegin, pend));
return *this;
}
template <class In>
-void ustring::insert(ustring::iterator p, In pbegin, In pend)
+void
+ustring::insert(ustring::iterator p, In pbegin, In pend)
{
string_.insert(p.base(), Glib::ustring::SequenceToString<In>(pbegin, pend));
}
template <class In>
-ustring& ustring::replace(ustring::iterator pbegin, ustring::iterator pend, In pbegin2, In pend2)
+ustring&
+ustring::replace(ustring::iterator pbegin, ustring::iterator pend, In pbegin2, In pend2)
{
- string_.replace(
- pbegin.base(), pend.base(),
- Glib::ustring::SequenceToString<In>(pbegin2, pend2));
+ string_.replace(pbegin.base(), pend.base(), Glib::ustring::SequenceToString<In>(pbegin2, pend2));
return *this;
}
// The ustring methods substr() and operator std::string() are inline,
// so that the compiler has a fair chance to optimize the copy ctor away.
-inline
-ustring ustring::substr(ustring::size_type i, ustring::size_type n) const
+inline ustring
+ustring::substr(ustring::size_type i, ustring::size_type n) const
{
return ustring(*this, i, n);
}
-inline
-ustring::operator std::string() const
+inline ustring::operator std::string() const
{
return string_;
}
-inline
-const std::string& ustring::raw() const
+inline const std::string&
+ustring::raw() const
{
return string_;
}
template <class T1>
inline // static
-ustring ustring::format(const T1& a1)
+ ustring
+ ustring::format(const T1& a1)
{
ustring::FormatStream buf;
buf.stream(a1);
@@ -1175,7 +1140,8 @@ ustring ustring::format(const T1& a1)
template <class T1, class T2>
inline // static
-ustring ustring::format(const T1& a1, const T2& a2)
+ ustring
+ ustring::format(const T1& a1, const T2& a2)
{
ustring::FormatStream buf;
buf.stream(a1);
@@ -1185,7 +1151,8 @@ ustring ustring::format(const T1& a1, const T2& a2)
template <class T1, class T2, class T3>
inline // static
-ustring ustring::format(const T1& a1, const T2& a2, const T3& a3)
+ ustring
+ ustring::format(const T1& a1, const T2& a2, const T3& a3)
{
ustring::FormatStream buf;
buf.stream(a1);
@@ -1196,7 +1163,8 @@ ustring ustring::format(const T1& a1, const T2& a2, const T3& a3)
template <class T1, class T2, class T3, class T4>
inline // static
-ustring ustring::format(const T1& a1, const T2& a2, const T3& a3, const T4& a4)
+ ustring
+ ustring::format(const T1& a1, const T2& a2, const T3& a3, const T4& a4)
{
ustring::FormatStream buf;
buf.stream(a1);
@@ -1208,8 +1176,8 @@ ustring ustring::format(const T1& a1, const T2& a2, const T3& a3, const T4& a4)
template <class T1, class T2, class T3, class T4, class T5>
inline // static
-ustring ustring::format(const T1& a1, const T2& a2, const T3& a3,
- const T4& a4, const T5& a5)
+ ustring
+ ustring::format(const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5)
{
ustring::FormatStream buf;
buf.stream(a1);
@@ -1222,8 +1190,9 @@ ustring ustring::format(const T1& a1, const T2& a2, const T3& a3,
template <class T1, class T2, class T3, class T4, class T5, class T6>
inline // static
-ustring ustring::format(const T1& a1, const T2& a2, const T3& a3,
- const T4& a4, const T5& a5, const T6& a6)
+ ustring
+ ustring::format(
+ const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5, const T6& a6)
{
ustring::FormatStream buf;
buf.stream(a1);
@@ -1235,11 +1204,11 @@ ustring ustring::format(const T1& a1, const T2& a2, const T3& a3,
return buf.to_string();
}
-template <class T1, class T2, class T3, class T4,
- class T5, class T6, class T7>
+template <class T1, class T2, class T3, class T4, class T5, class T6, class T7>
inline // static
-ustring ustring::format(const T1& a1, const T2& a2, const T3& a3, const T4& a4,
- const T5& a5, const T6& a6, const T7& a7)
+ ustring
+ ustring::format(const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5,
+ const T6& a6, const T7& a7)
{
ustring::FormatStream buf;
buf.stream(a1);
@@ -1252,11 +1221,11 @@ ustring ustring::format(const T1& a1, const T2& a2, const T3& a3, const T4& a4,
return buf.to_string();
}
-template <class T1, class T2, class T3, class T4,
- class T5, class T6, class T7, class T8>
+template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
inline // static
-ustring ustring::format(const T1& a1, const T2& a2, const T3& a3, const T4& a4,
- const T5& a5, const T6& a6, const T7& a7, const T8& a8)
+ ustring
+ ustring::format(const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5,
+ const T6& a6, const T7& a7, const T8& a8)
{
ustring::FormatStream buf;
buf.stream(a1);
@@ -1279,9 +1248,9 @@ private:
ustring string_;
public:
- explicit inline Stringify(const T& arg) : string_ (ustring::format(arg)) {}
+ explicit inline Stringify(const T& arg) : string_(ustring::format(arg)) {}
- //TODO: Why is this here? See the template specialization:
+ // TODO: Why is this here? See the template specialization:
explicit inline Stringify(const char* arg) : string_(arg) {}
// noncopyable
@@ -1368,64 +1337,67 @@ public:
template <class T1>
inline // static
-ustring ustring::compose(const ustring& fmt)
+ ustring
+ ustring::compose(const ustring& fmt)
{
return ustring::compose_argv(fmt, 0, nullptr);
}
template <class T1>
inline // static
-ustring ustring::compose(const ustring& fmt, const T1& a1)
+ ustring
+ ustring::compose(const ustring& fmt, const T1& a1)
{
const ustring::Stringify<T1> s1(a1);
- const ustring *const argv[] = { s1.ptr() };
+ const ustring* const argv[] = { s1.ptr() };
return ustring::compose_argv(fmt, G_N_ELEMENTS(argv), argv);
}
template <class T1, class T2>
inline // static
-ustring ustring::compose(const ustring& fmt, const T1& a1, const T2& a2)
+ ustring
+ ustring::compose(const ustring& fmt, const T1& a1, const T2& a2)
{
const ustring::Stringify<T1> s1(a1);
const ustring::Stringify<T2> s2(a2);
- const ustring *const argv[] = { s1.ptr(), s2.ptr() };
+ const ustring* const argv[] = { s1.ptr(), s2.ptr() };
return ustring::compose_argv(fmt, G_N_ELEMENTS(argv), argv);
}
template <class T1, class T2, class T3>
inline // static
-ustring ustring::compose(const ustring& fmt,
- const T1& a1, const T2& a2, const T3& a3)
+ ustring
+ ustring::compose(const ustring& fmt, const T1& a1, const T2& a2, const T3& a3)
{
const ustring::Stringify<T1> s1(a1);
const ustring::Stringify<T2> s2(a2);
const ustring::Stringify<T3> s3(a3);
- const ustring *const argv[] = { s1.ptr(), s2.ptr(), s3.ptr() };
+ const ustring* const argv[] = { s1.ptr(), s2.ptr(), s3.ptr() };
return ustring::compose_argv(fmt, G_N_ELEMENTS(argv), argv);
}
template <class T1, class T2, class T3, class T4>
inline // static
-ustring ustring::compose(const ustring& fmt,
- const T1& a1, const T2& a2, const T3& a3, const T4& a4)
+ ustring
+ ustring::compose(const ustring& fmt, const T1& a1, const T2& a2, const T3& a3, const T4& a4)
{
const ustring::Stringify<T1> s1(a1);
const ustring::Stringify<T2> s2(a2);
const ustring::Stringify<T3> s3(a3);
const ustring::Stringify<T4> s4(a4);
- const ustring *const argv[] = { s1.ptr(), s2.ptr(), s3.ptr(), s4.ptr() };
+ const ustring* const argv[] = { s1.ptr(), s2.ptr(), s3.ptr(), s4.ptr() };
return ustring::compose_argv(fmt, G_N_ELEMENTS(argv), argv);
}
template <class T1, class T2, class T3, class T4, class T5>
inline // static
-ustring ustring::compose(const ustring& fmt,
- const T1& a1, const T2& a2, const T3& a3,
- const T4& a4, const T5& a5)
+ ustring
+ ustring::compose(
+ const ustring& fmt, const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5)
{
const ustring::Stringify<T1> s1(a1);
const ustring::Stringify<T2> s2(a2);
@@ -1433,15 +1405,15 @@ ustring ustring::compose(const ustring& fmt,
const ustring::Stringify<T4> s4(a4);
const ustring::Stringify<T5> s5(a5);
- const ustring *const argv[] = { s1.ptr(), s2.ptr(), s3.ptr(), s4.ptr(), s5.ptr() };
+ const ustring* const argv[] = { s1.ptr(), s2.ptr(), s3.ptr(), s4.ptr(), s5.ptr() };
return ustring::compose_argv(fmt, G_N_ELEMENTS(argv), argv);
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
inline // static
-ustring ustring::compose(const ustring& fmt,
- const T1& a1, const T2& a2, const T3& a3,
- const T4& a4, const T5& a5, const T6& a6)
+ ustring
+ ustring::compose(const ustring& fmt, const T1& a1, const T2& a2, const T3& a3, const T4& a4,
+ const T5& a5, const T6& a6)
{
const ustring::Stringify<T1> s1(a1);
const ustring::Stringify<T2> s2(a2);
@@ -1450,16 +1422,15 @@ ustring ustring::compose(const ustring& fmt,
const ustring::Stringify<T5> s5(a5);
const ustring::Stringify<T6> s6(a6);
- const ustring *const argv[] = { s1.ptr(), s2.ptr(), s3.ptr(), s4.ptr(),
- s5.ptr(), s6.ptr() };
+ const ustring* const argv[] = { s1.ptr(), s2.ptr(), s3.ptr(), s4.ptr(), s5.ptr(), s6.ptr() };
return ustring::compose_argv(fmt, G_N_ELEMENTS(argv), argv);
}
template <class T1, class T2, class T3, class T4, class T5, class T6, class T7>
inline // static
-ustring ustring::compose(const ustring& fmt,
- const T1& a1, const T2& a2, const T3& a3,
- const T4& a4, const T5& a5, const T6& a6, const T7& a7)
+ ustring
+ ustring::compose(const ustring& fmt, const T1& a1, const T2& a2, const T3& a3, const T4& a4,
+ const T5& a5, const T6& a6, const T7& a7)
{
const ustring::Stringify<T1> s1(a1);
const ustring::Stringify<T2> s2(a2);
@@ -1469,18 +1440,16 @@ ustring ustring::compose(const ustring& fmt,
const ustring::Stringify<T6> s6(a6);
const ustring::Stringify<T7> s7(a7);
- const ustring *const argv[] = { s1.ptr(), s2.ptr(), s3.ptr(), s4.ptr(),
- s5.ptr(), s6.ptr(), s7.ptr() };
+ const ustring* const argv[] = { s1.ptr(), s2.ptr(), s3.ptr(), s4.ptr(), s5.ptr(), s6.ptr(),
+ s7.ptr() };
return ustring::compose_argv(fmt, G_N_ELEMENTS(argv), argv);
}
-template <class T1, class T2, class T3, class T4,
- class T5, class T6, class T7, class T8>
+template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
inline // static
-ustring ustring::compose(const ustring& fmt,
- const T1& a1, const T2& a2, const T3& a3,
- const T4& a4, const T5& a5, const T6& a6,
- const T7& a7, const T8& a8)
+ ustring
+ ustring::compose(const ustring& fmt, const T1& a1, const T2& a2, const T3& a3, const T4& a4,
+ const T5& a5, const T6& a6, const T7& a7, const T8& a8)
{
const ustring::Stringify<T1> s1(a1);
const ustring::Stringify<T2> s2(a2);
@@ -1491,18 +1460,16 @@ ustring ustring::compose(const ustring& fmt,
const ustring::Stringify<T7> s7(a7);
const ustring::Stringify<T8> s8(a8);
- const ustring *const argv[] = { s1.ptr(), s2.ptr(), s3.ptr(), s4.ptr(),
- s5.ptr(), s6.ptr(), s7.ptr(), s8.ptr() };
+ const ustring* const argv[] = { s1.ptr(), s2.ptr(), s3.ptr(), s4.ptr(), s5.ptr(), s6.ptr(),
+ s7.ptr(), s8.ptr() };
return ustring::compose_argv(fmt, G_N_ELEMENTS(argv), argv);
}
-template <class T1, class T2, class T3, class T4, class T5,
- class T6, class T7, class T8, class T9>
+template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
inline // static
-ustring ustring::compose(const ustring& fmt,
- const T1& a1, const T2& a2, const T3& a3,
- const T4& a4, const T5& a5, const T6& a6,
- const T7& a7, const T8& a8, const T9& a9)
+ ustring
+ ustring::compose(const ustring& fmt, const T1& a1, const T2& a2, const T3& a3, const T4& a4,
+ const T5& a5, const T6& a6, const T7& a7, const T8& a8, const T9& a9)
{
const ustring::Stringify<T1> s1(a1);
const ustring::Stringify<T2> s2(a2);
@@ -1514,100 +1481,147 @@ ustring ustring::compose(const ustring& fmt,
const ustring::Stringify<T8> s8(a8);
const ustring::Stringify<T9> s9(a9);
- const ustring *const argv[] = { s1.ptr(), s2.ptr(), s3.ptr(), s4.ptr(),
- s5.ptr(), s6.ptr(), s7.ptr(), s8.ptr(), s9.ptr() };
+ const ustring* const argv[] = { s1.ptr(), s2.ptr(), s3.ptr(), s4.ptr(), s5.ptr(), s6.ptr(),
+ s7.ptr(), s8.ptr(), s9.ptr() };
return ustring::compose_argv(fmt, G_N_ELEMENTS(argv), argv);
}
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
/** @relates Glib::ustring */
-inline
-void swap(ustring& lhs, ustring& rhs)
+inline void
+swap(ustring& lhs, ustring& rhs)
{
lhs.swap(rhs);
}
-
/**** Glib::ustring -- comparison operators ********************************/
/** @relates Glib::ustring */
-inline bool operator==(const ustring& lhs, const ustring& rhs)
- { return (lhs.compare(rhs) == 0); }
+inline bool
+operator==(const ustring& lhs, const ustring& rhs)
+{
+ return (lhs.compare(rhs) == 0);
+}
/** @relates Glib::ustring */
-inline bool operator==(const ustring& lhs, const char* rhs)
- { return (lhs.compare(rhs) == 0); }
+inline bool
+operator==(const ustring& lhs, const char* rhs)
+{
+ return (lhs.compare(rhs) == 0);
+}
/** @relates Glib::ustring */
-inline bool operator==(const char* lhs, const ustring& rhs)
- { return (rhs.compare(lhs) == 0); }
-
+inline bool
+operator==(const char* lhs, const ustring& rhs)
+{
+ return (rhs.compare(lhs) == 0);
+}
/** @relates Glib::ustring */
-inline bool operator!=(const ustring& lhs, const ustring& rhs)
- { return (lhs.compare(rhs) != 0); }
+inline bool
+operator!=(const ustring& lhs, const ustring& rhs)
+{
+ return (lhs.compare(rhs) != 0);
+}
/** @relates Glib::ustring */
-inline bool operator!=(const ustring& lhs, const char* rhs)
- { return (lhs.compare(rhs) != 0); }
+inline bool
+operator!=(const ustring& lhs, const char* rhs)
+{
+ return (lhs.compare(rhs) != 0);
+}
/** @relates Glib::ustring */
-inline bool operator!=(const char* lhs, const ustring& rhs)
- { return (rhs.compare(lhs) != 0); }
-
+inline bool
+operator!=(const char* lhs, const ustring& rhs)
+{
+ return (rhs.compare(lhs) != 0);
+}
/** @relates Glib::ustring */
-inline bool operator<(const ustring& lhs, const ustring& rhs)
- { return (lhs.compare(rhs) < 0); }
+inline bool
+operator<(const ustring& lhs, const ustring& rhs)
+{
+ return (lhs.compare(rhs) < 0);
+}
/** @relates Glib::ustring */
-inline bool operator<(const ustring& lhs, const char* rhs)
- { return (lhs.compare(rhs) < 0); }
+inline bool
+operator<(const ustring& lhs, const char* rhs)
+{
+ return (lhs.compare(rhs) < 0);
+}
/** @relates Glib::ustring */
-inline bool operator<(const char* lhs, const ustring& rhs)
- { return (rhs.compare(lhs) > 0); }
-
+inline bool
+operator<(const char* lhs, const ustring& rhs)
+{
+ return (rhs.compare(lhs) > 0);
+}
/** @relates Glib::ustring */
-inline bool operator>(const ustring& lhs, const ustring& rhs)
- { return (lhs.compare(rhs) > 0); }
+inline bool
+operator>(const ustring& lhs, const ustring& rhs)
+{
+ return (lhs.compare(rhs) > 0);
+}
/** @relates Glib::ustring */
-inline bool operator>(const ustring& lhs, const char* rhs)
- { return (lhs.compare(rhs) > 0); }
+inline bool
+operator>(const ustring& lhs, const char* rhs)
+{
+ return (lhs.compare(rhs) > 0);
+}
/** @relates Glib::ustring */
-inline bool operator>(const char* lhs, const ustring& rhs)
- { return (rhs.compare(lhs) < 0); }
-
+inline bool
+operator>(const char* lhs, const ustring& rhs)
+{
+ return (rhs.compare(lhs) < 0);
+}
/** @relates Glib::ustring */
-inline bool operator<=(const ustring& lhs, const ustring& rhs)
- { return (lhs.compare(rhs) <= 0); }
+inline bool
+operator<=(const ustring& lhs, const ustring& rhs)
+{
+ return (lhs.compare(rhs) <= 0);
+}
/** @relates Glib::ustring */
-inline bool operator<=(const ustring& lhs, const char* rhs)
- { return (lhs.compare(rhs) <= 0); }
+inline bool
+operator<=(const ustring& lhs, const char* rhs)
+{
+ return (lhs.compare(rhs) <= 0);
+}
/** @relates Glib::ustring */
-inline bool operator<=(const char* lhs, const ustring& rhs)
- { return (rhs.compare(lhs) >= 0); }
-
+inline bool
+operator<=(const char* lhs, const ustring& rhs)
+{
+ return (rhs.compare(lhs) >= 0);
+}
/** @relates Glib::ustring */
-inline bool operator>=(const ustring& lhs, const ustring& rhs)
- { return (lhs.compare(rhs) >= 0); }
+inline bool
+operator>=(const ustring& lhs, const ustring& rhs)
+{
+ return (lhs.compare(rhs) >= 0);
+}
/** @relates Glib::ustring */
-inline bool operator>=(const ustring& lhs, const char* rhs)
- { return (lhs.compare(rhs) >= 0); }
+inline bool
+operator>=(const ustring& lhs, const char* rhs)
+{
+ return (lhs.compare(rhs) >= 0);
+}
/** @relates Glib::ustring */
-inline bool operator>=(const char* lhs, const ustring& rhs)
- { return (rhs.compare(lhs) <= 0); }
+inline bool
+operator>=(const char* lhs, const ustring& rhs)
+{
+ return (rhs.compare(lhs) <= 0);
+}
#ifndef DOXYGEN_SHOULD_SKIP_THIS
// Don't allow implicit conversion of integer 0 to nullptr in the relational operators.
@@ -1631,7 +1645,8 @@ bool operator>=(int lhs, const ustring& rhs) = delete;
/**** Glib::ustring -- concatenation operators *****************************/
/** @relates Glib::ustring */
-inline ustring operator+(const ustring& lhs, const ustring& rhs)
+inline ustring
+operator+(const ustring& lhs, const ustring& rhs)
{
ustring temp(lhs);
temp += rhs;
@@ -1639,7 +1654,8 @@ inline ustring operator+(const ustring& lhs, const ustring& rhs)
}
/** @relates Glib::ustring */
-inline ustring operator+(const ustring& lhs, const char* rhs)
+inline ustring
+operator+(const ustring& lhs, const char* rhs)
{
ustring temp(lhs);
temp += rhs;
@@ -1647,7 +1663,8 @@ inline ustring operator+(const ustring& lhs, const char* rhs)
}
/** @relates Glib::ustring */
-inline ustring operator+(const char* lhs, const ustring& rhs)
+inline ustring
+operator+(const char* lhs, const ustring& rhs)
{
ustring temp(lhs);
temp += rhs;
@@ -1655,7 +1672,8 @@ inline ustring operator+(const char* lhs, const ustring& rhs)
}
/** @relates Glib::ustring */
-inline ustring operator+(const ustring& lhs, gunichar rhs)
+inline ustring
+operator+(const ustring& lhs, gunichar rhs)
{
ustring temp(lhs);
temp += rhs;
@@ -1663,7 +1681,8 @@ inline ustring operator+(const ustring& lhs, gunichar rhs)
}
/** @relates Glib::ustring */
-inline ustring operator+(gunichar lhs, const ustring& rhs)
+inline ustring
+operator+(gunichar lhs, const ustring& rhs)
{
ustring temp(1, lhs);
temp += rhs;
@@ -1671,7 +1690,8 @@ inline ustring operator+(gunichar lhs, const ustring& rhs)
}
/** @relates Glib::ustring */
-inline ustring operator+(const ustring& lhs, char rhs)
+inline ustring
+operator+(const ustring& lhs, char rhs)
{
ustring temp(lhs);
temp += rhs;
@@ -1679,7 +1699,8 @@ inline ustring operator+(const ustring& lhs, char rhs)
}
/** @relates Glib::ustring */
-inline ustring operator+(char lhs, const ustring& rhs)
+inline ustring
+operator+(char lhs, const ustring& rhs)
{
ustring temp(1, lhs);
temp += rhs;
@@ -1688,5 +1709,4 @@ inline ustring operator+(char lhs, const ustring& rhs)
} // namespace Glib
-
#endif /* _GLIBMM_USTRING_H */
diff --git a/glib/glibmm/utility.h b/glib/glibmm/utility.h
index cae4452..096b9fe 100644
--- a/glib/glibmm/utility.h
+++ b/glib/glibmm/utility.h
@@ -41,17 +41,20 @@
#else
-//TODO: This causes warnings like this:
+// TODO: This causes warnings like this:
//"missing initializer for member"
#define GLIBMM_INITIALIZE_STRUCT(Var, Type) \
- G_STMT_START{ \
- Type const temp_initializer__ = { 0, }; \
- (Var) = temp_initializer__; \
- }G_STMT_END
+ G_STMT_START \
+ { \
+ Type const temp_initializer__ = { \
+ 0, \
+ }; \
+ (Var) = temp_initializer__; \
+ } \
+ G_STMT_END
#endif
-#endif //GLIBMM_DISABLE_DEPRECATED
-
+#endif // GLIBMM_DISABLE_DEPRECATED
namespace Glib
{
@@ -73,13 +76,13 @@ private:
ScopedPtr<T>& operator=(const ScopedPtr<T>&);
public:
- ScopedPtr() : ptr_ (nullptr) {}
- explicit ScopedPtr(T* ptr) : ptr_ (ptr) {}
- ~ScopedPtr() noexcept { g_free(ptr_); }
- T* get() const { return ptr_; }
- T** addr() { return &ptr_; }
+ ScopedPtr() : ptr_(nullptr) {}
+ explicit ScopedPtr(T* ptr) : ptr_(ptr) {}
+ ~ScopedPtr() noexcept { g_free(ptr_); }
+ T* get() const { return ptr_; }
+ T** addr() { return &ptr_; }
};
-#endif //GLIBMM_DISABLE_DEPRECATED
+#endif // GLIBMM_DISABLE_DEPRECATED
/** Helper to deal with memory allocated
* by GLib functions in an exception-safe manner.
@@ -87,54 +90,57 @@ public:
* This just creates a std::unique_ptr that uses g_free() as its deleter.
*/
template <typename T>
-std::unique_ptr<T[], decltype(&g_free)> make_unique_ptr_gfree(T* p)
+std::unique_ptr<T[], decltype(&g_free)>
+make_unique_ptr_gfree(T* p)
{
return std::unique_ptr<T[], decltype(&g_free)>(p, &g_free);
}
-//TODO: Deprecate this? We don't use it ourselves.
+// TODO: Deprecate this? We don't use it ourselves.
/** Removes the const nature of a ptr
*
*/
template <class T>
-inline T* unconst(const T* t)
- { return const_cast<T*>(t); }
+inline T*
+unconst(const T* t)
+{
+ return const_cast<T*>(t);
+}
// Convert const gchar* to ustring, while treating NULL as empty string.
-inline
-Glib::ustring convert_const_gchar_ptr_to_ustring(const char* str)
+inline Glib::ustring
+convert_const_gchar_ptr_to_ustring(const char* str)
{
return (str) ? Glib::ustring(str) : Glib::ustring();
}
// Convert const gchar* to std::string, while treating NULL as empty string.
-inline
-std::string convert_const_gchar_ptr_to_stdstring(const char* str)
+inline std::string
+convert_const_gchar_ptr_to_stdstring(const char* str)
{
return (str) ? std::string(str) : std::string();
}
// Convert a non-const gchar* return value to ustring, freeing it too.
-inline
-Glib::ustring convert_return_gchar_ptr_to_ustring(char* str)
+inline Glib::ustring
+convert_return_gchar_ptr_to_ustring(char* str)
{
- return (str) ? Glib::ustring(Glib::make_unique_ptr_gfree(str).get())
- : Glib::ustring();
+ return (str) ? Glib::ustring(Glib::make_unique_ptr_gfree(str).get()) : Glib::ustring();
}
// Convert a non-const gchar* return value to std::string, freeing it too.
-inline
-std::string convert_return_gchar_ptr_to_stdstring(char* str)
+inline std::string
+convert_return_gchar_ptr_to_stdstring(char* str)
{
- return (str) ? std::string(Glib::make_unique_ptr_gfree(str).get())
- : std::string();
+ return (str) ? std::string(Glib::make_unique_ptr_gfree(str).get()) : std::string();
}
/** Get a pointer to the C style string in a std::string or Glib::ustring.
* If the string is empty, a nullptr is returned.
*/
template <typename T>
-inline const char* c_str_or_nullptr(const T& str)
+inline const char*
+c_str_or_nullptr(const T& str)
{
return str.empty() ? nullptr : str.c_str();
}
@@ -147,7 +153,8 @@ void append_canonical_typename(std::string& dest, const char* type_name);
// that take a GDestroyNotify parameter, such as g_object_set_qdata_full()
// and g_option_group_set_translate_func().
template <typename T>
-void destroy_notify_delete(void* data)
+void
+destroy_notify_delete(void* data)
{
delete static_cast<T*>(data);
}
diff --git a/glib/glibmm/value.h b/glib/glibmm/value.h
index 2c5c570..3a51628 100644
--- a/glib/glibmm/value.h
+++ b/glib/glibmm/value.h
@@ -86,7 +86,7 @@ public:
*/
void reset();
- GValue* gobj() { return &gobject_; }
+ GValue* gobj() { return &gobject_; }
const GValue* gobj() const { return &gobject_; }
protected:
@@ -106,11 +106,10 @@ public:
#endif
protected:
- void set_boxed(const void* data);
+ void set_boxed(const void* data);
void* get_boxed() const; // doesn't copy
};
-
/**
* @ingroup glibmmValue
*/
@@ -129,7 +128,6 @@ protected:
Glib::RefPtr<Glib::ObjectBase> get_object_copy() const;
};
-
/**
* @ingroup glibmmValue
*/
@@ -145,10 +143,9 @@ public:
protected:
void set_enum(int data);
- int get_enum() const;
+ int get_enum() const;
};
-
/**
* @ingroup glibmmValue
*/
@@ -167,7 +164,6 @@ protected:
unsigned int get_flags() const;
};
-
/**
* @ingroup glibmmValue
*/
@@ -188,14 +184,12 @@ protected:
} // namespace Glib
-
/* Include generic Glib::Value<> template, before any specializations:
*/
#define _GLIBMM_VALUE_H_INCLUDE_VALUE_CUSTOM_H
#include <glibmm/value_custom.h>
#undef _GLIBMM_VALUE_H_INCLUDE_VALUE_CUSTOM_H
-
namespace Glib
{
@@ -206,66 +200,64 @@ template <class T>
class Value_Boxed : public ValueBase_Boxed
{
public:
- typedef T CppType;
+ typedef T CppType;
typedef typename T::BaseObjectType* CType;
static GType value_type() { return T::get_type(); }
void set(const CppType& data) { set_boxed(data.gobj()); }
- CppType get() const { return CppType(static_cast<CType>(get_boxed())); }
+ CppType get() const { return CppType(static_cast<CType>(get_boxed())); }
};
-//More spec-compliant compilers (such as Tru64) need this to be near Glib::Object instead.
+// More spec-compliant compilers (such as Tru64) need this to be near Glib::Object instead.
#ifdef GLIBMM_CAN_USE_DYNAMIC_CAST_IN_UNUSED_TEMPLATE_WITHOUT_DEFINITION
/** Partial specialization for RefPtr<> to Glib::Object.
* @ingroup glibmmValue
*/
template <class T>
-class Value< Glib::RefPtr<T> > : public ValueBase_Object
+class Value<Glib::RefPtr<T>> : public ValueBase_Object
{
public:
- typedef Glib::RefPtr<T> CppType;
+ typedef Glib::RefPtr<T> CppType;
typedef typename T::BaseObjectType* CType;
static GType value_type() { return T::get_base_type(); }
void set(const CppType& data) { set_object(data.operator->()); }
- CppType get() const { return Glib::RefPtr<T>::cast_dynamic(get_object_copy()); }
+ CppType get() const { return Glib::RefPtr<T>::cast_dynamic(get_object_copy()); }
};
-//The SUN Forte Compiler has a problem with this:
+// The SUN Forte Compiler has a problem with this:
#ifdef GLIBMM_HAVE_DISAMBIGUOUS_CONST_TEMPLATE_SPECIALIZATIONS
/** Partial specialization for RefPtr<> to const Glib::Object.
* @ingroup glibmmValue
*/
template <class T>
-class Value< Glib::RefPtr<const T> > : public ValueBase_Object
+class Value<Glib::RefPtr<const T>> : public ValueBase_Object
{
public:
- typedef Glib::RefPtr<const T> CppType;
+ typedef Glib::RefPtr<const T> CppType;
typedef typename T::BaseObjectType* CType;
static GType value_type() { return T::get_base_type(); }
void set(const CppType& data) { set_object(const_cast<T*>(data.operator->())); }
- CppType get() const { return Glib::RefPtr<T>::cast_dynamic(get_object_copy()); }
+ CppType get() const { return Glib::RefPtr<T>::cast_dynamic(get_object_copy()); }
};
-#endif //GLIBMM_HAVE_DISAMBIGUOUS_CONST_TEMPLATE_SPECIALIZATIONS
+#endif // GLIBMM_HAVE_DISAMBIGUOUS_CONST_TEMPLATE_SPECIALIZATIONS
-#endif //GLIBMM_CAN_USE_DYNAMIC_CAST_IN_UNUSED_TEMPLATE_WITHOUT_DEFINITION
+#endif // GLIBMM_CAN_USE_DYNAMIC_CAST_IN_UNUSED_TEMPLATE_WITHOUT_DEFINITION
} // namespace Glib
-
/* Include generated specializations of Glib::Value<> for fundamental types:
*/
#define _GLIBMM_VALUE_H_INCLUDE_VALUE_BASICTYPES_H
#include <glibmm/value_basictypes.h>
#undef _GLIBMM_VALUE_H_INCLUDE_VALUE_BASICTYPES_H
-
namespace Glib
{
@@ -295,7 +287,6 @@ public:
Glib::ustring get() const { return get_cstring(); }
};
-
/** Base class of Glib::Value<T> specializations for enum types.
* @ingroup glibmmValue
*/
@@ -306,7 +297,7 @@ public:
typedef T CppType;
void set(CppType data) { set_enum(data); }
- CppType get() const { return CppType(get_enum()); }
+ CppType get() const { return CppType(get_enum()); }
};
/** Base class of Glib::Value<T> specializations for flags types.
@@ -319,10 +310,9 @@ public:
typedef T CppType;
void set(CppType data) { set_flags(data); }
- CppType get() const { return CppType(get_flags()); }
+ CppType get() const { return CppType(get_flags()); }
};
} // namespace Glib
-
#endif /* _GLIBMM_VALUE_H */
diff --git a/glib/glibmm/value_custom.h b/glib/glibmm/value_custom.h
index bfcd074..f94bf1b 100644
--- a/glib/glibmm/value_custom.h
+++ b/glib/glibmm/value_custom.h
@@ -33,21 +33,18 @@ namespace Glib
#ifndef DOXYGEN_SHOULD_SKIP_THIS
-extern "C"
-{
- typedef void (* ValueInitFunc) (GValue*);
- typedef void (* ValueFreeFunc) (GValue*);
- typedef void (* ValueCopyFunc) (const GValue*, GValue*);
+extern "C" {
+typedef void (*ValueInitFunc)(GValue*);
+typedef void (*ValueFreeFunc)(GValue*);
+typedef void (*ValueCopyFunc)(const GValue*, GValue*);
}
/* When using Glib::Value<T> with custom types, each T will be registered
* as subtype of G_TYPE_BOXED, via this function. The type_name argument
* should be the C++ RTTI name.
*/
-GType custom_boxed_type_register(const char* type_name,
- ValueInitFunc init_func,
- ValueFreeFunc free_func,
- ValueCopyFunc copy_func);
+GType custom_boxed_type_register(
+ const char* type_name, ValueInitFunc init_func, ValueFreeFunc free_func, ValueCopyFunc copy_func);
/* When using Glib::Value<T*> or Glib::Value<const T*> with custom types,
* each T* or const T* will be registered as a subtype of G_TYPE_POINTER,
@@ -57,7 +54,6 @@ GType custom_pointer_type_register(const char* type_name);
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
/**
* @ingroup glibmmValue
*/
@@ -65,7 +61,7 @@ template <class T, class PtrT>
class Value_Pointer : public ValueBase_Object
{
public:
- typedef PtrT CppType;
+ typedef PtrT CppType;
typedef void* CType;
static inline GType value_type() G_GNUC_CONST;
@@ -74,8 +70,7 @@ public:
inline CppType get() const;
private:
- inline
- static GType value_type_(Glib::Object*);
+ inline static GType value_type_(Glib::Object*);
static GType value_type_(void*);
inline void set_(CppType data, Glib::Object*);
@@ -85,7 +80,6 @@ private:
inline CppType get_(void*) const;
};
-
/** Generic value implementation for custom types.
* @ingroup glibmmValue
* Any type to be used with this template must implement:
@@ -106,7 +100,7 @@ template <class T>
class Value : public ValueBase_Boxed
{
public:
- typedef T CppType;
+ typedef T CppType;
typedef T* CType;
static GType value_type() G_GNUC_CONST;
@@ -122,15 +116,15 @@ private:
static void value_copy_func(const GValue* src_value, GValue* dest_value);
};
-
/** Specialization for pointers to instances of any type.
* @ingroup glibmmValue
* No attempt is made to manage the memory associated with the
* pointer, you must take care of that yourself.
*/
template <class T>
-class Value<T*> : public Value_Pointer<T,T*>
-{};
+class Value<T*> : public Value_Pointer<T, T*>
+{
+};
/** Specialization for pointers to const instances of any type.
* @ingroup glibmmValue
@@ -138,9 +132,9 @@ class Value<T*> : public Value_Pointer<T,T*>
* pointer, you must take care of that yourself.
*/
template <class T>
-class Value<const T*> : public Value_Pointer<T,const T*>
-{};
-
+class Value<const T*> : public Value_Pointer<T, const T*>
+{
+};
#ifndef DOXYGEN_SHOULD_SKIP_THIS
@@ -149,49 +143,55 @@ class Value<const T*> : public Value_Pointer<T,const T*>
/** Implementation for Glib::Object pointers **/
// static
-template <class T, class PtrT> inline
-GType Value_Pointer<T,PtrT>::value_type_(Glib::Object*)
+template <class T, class PtrT>
+inline GType
+Value_Pointer<T, PtrT>::value_type_(Glib::Object*)
{
return T::get_base_type();
}
-template <class T, class PtrT> inline
-void Value_Pointer<T,PtrT>::set_(PtrT data, Glib::Object*)
+template <class T, class PtrT>
+inline void
+Value_Pointer<T, PtrT>::set_(PtrT data, Glib::Object*)
{
set_object(const_cast<T*>(data));
}
-//More spec-compliant compilers (such as Tru64) need this to be near Glib::Object instead.
+// More spec-compliant compilers (such as Tru64) need this to be near Glib::Object instead.
#ifdef GLIBMM_CAN_USE_DYNAMIC_CAST_IN_UNUSED_TEMPLATE_WITHOUT_DEFINITION
-template <class T, class PtrT> inline
-PtrT Value_Pointer<T,PtrT>::get_(Glib::Object*) const
+template <class T, class PtrT>
+inline PtrT
+Value_Pointer<T, PtrT>::get_(Glib::Object*) const
{
return dynamic_cast<T*>(get_object());
}
-#endif //GLIBMM_CAN_USE_DYNAMIC_CAST_IN_UNUSED_TEMPLATE_WITHOUT_DEFINITION
+#endif // GLIBMM_CAN_USE_DYNAMIC_CAST_IN_UNUSED_TEMPLATE_WITHOUT_DEFINITION
/** Implementation for custom pointers **/
// static
template <class T, class PtrT>
-GType Value_Pointer<T,PtrT>::value_type_(void*)
+GType
+Value_Pointer<T, PtrT>::value_type_(void*)
{
static GType custom_type = 0;
- if(!custom_type)
+ if (!custom_type)
custom_type = Glib::custom_pointer_type_register(typeid(PtrT).name());
return custom_type;
}
-template <class T, class PtrT> inline
-void Value_Pointer<T,PtrT>::set_(PtrT data, void*)
+template <class T, class PtrT>
+inline void
+Value_Pointer<T, PtrT>::set_(PtrT data, void*)
{
gobject_.data[0].v_pointer = const_cast<T*>(data);
}
-template <class T, class PtrT> inline
-PtrT Value_Pointer<T,PtrT>::get_(void*) const
+template <class T, class PtrT>
+inline PtrT
+Value_Pointer<T, PtrT>::get_(void*) const
{
return static_cast<T*>(gobject_.data[0].v_pointer);
}
@@ -199,43 +199,47 @@ PtrT Value_Pointer<T,PtrT>::get_(void*) const
/** Public forwarding interface **/
// static
-template <class T, class PtrT> inline
-GType Value_Pointer<T,PtrT>::value_type()
+template <class T, class PtrT>
+inline GType
+Value_Pointer<T, PtrT>::value_type()
{
// Dispatch to the specific value_type_() overload.
- return Value_Pointer<T,PtrT>::value_type_(static_cast<T*>(nullptr));
+ return Value_Pointer<T, PtrT>::value_type_(static_cast<T*>(nullptr));
}
-template <class T, class PtrT> inline
-void Value_Pointer<T,PtrT>::set(PtrT data)
+template <class T, class PtrT>
+inline void
+Value_Pointer<T, PtrT>::set(PtrT data)
{
// Dispatch to the specific set_() overload.
this->set_(data, static_cast<T*>(nullptr));
}
-template <class T, class PtrT> inline
-PtrT Value_Pointer<T,PtrT>::get() const
+template <class T, class PtrT>
+inline PtrT
+Value_Pointer<T, PtrT>::get() const
{
// Dispatch to the specific get_() overload.
return this->get_(static_cast<T*>(nullptr));
}
-
/**** Glib::Value<T> *******************************************************/
// Static data, specific to each template instantiation.
template <class T>
GType Value<T>::custom_type_ = 0;
-template <class T> inline
-void Value<T>::set(const typename Value<T>::CppType& data)
+template <class T>
+inline void
+Value<T>::set(const typename Value<T>::CppType& data)
{
// Assume the value is already default-initialized. See value_init_func().
*static_cast<T*>(gobject_.data[0].v_pointer) = data;
}
-template <class T> inline
-typename Value<T>::CppType Value<T>::get() const
+template <class T>
+inline typename Value<T>::CppType
+Value<T>::get() const
{
// Assume the pointer is not NULL. See value_init_func().
return *static_cast<T*>(gobject_.data[0].v_pointer);
@@ -243,41 +247,42 @@ typename Value<T>::CppType Value<T>::get() const
// static
template <class T>
-GType Value<T>::value_type()
+GType
+Value<T>::value_type()
{
- if(!custom_type_)
+ if (!custom_type_)
{
- custom_type_ = Glib::custom_boxed_type_register(
- typeid(CppType).name(),
- &Value<T>::value_init_func,
- &Value<T>::value_free_func,
- &Value<T>::value_copy_func);
+ custom_type_ = Glib::custom_boxed_type_register(typeid(CppType).name(),
+ &Value<T>::value_init_func, &Value<T>::value_free_func, &Value<T>::value_copy_func);
}
return custom_type_;
}
// static
template <class T>
-void Value<T>::value_init_func(GValue* value)
+void
+Value<T>::value_init_func(GValue* value)
{
// Never store a NULL pointer (unless we're out of memory).
- value->data[0].v_pointer = new(std::nothrow) T();
+ value->data[0].v_pointer = new (std::nothrow) T();
}
// static
template <class T>
-void Value<T>::value_free_func(GValue* value)
+void
+Value<T>::value_free_func(GValue* value)
{
delete static_cast<T*>(value->data[0].v_pointer);
}
// static
template <class T>
-void Value<T>::value_copy_func(const GValue* src_value, GValue* dest_value)
+void
+Value<T>::value_copy_func(const GValue* src_value, GValue* dest_value)
{
// Assume the source is not NULL. See value_init_func().
const T& source = *static_cast<T*>(src_value->data[0].v_pointer);
- dest_value->data[0].v_pointer = new(std::nothrow) T(source);
+ dest_value->data[0].v_pointer = new (std::nothrow) T(source);
}
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
diff --git a/glib/glibmm/vectorutils.h b/glib/glibmm/vectorutils.h
index a85ad97..40231db 100644
--- a/glib/glibmm/vectorutils.h
+++ b/glib/glibmm/vectorutils.h
@@ -68,18 +68,19 @@ namespace Container_Helpers
/* Count the number of elements in a 0-terminated sequence.
*/
-template <class T> inline
-std::size_t compute_array_size2(const T* array)
+template <class T>
+inline std::size_t
+compute_array_size2(const T* array)
{
- if(array)
+ if (array)
{
const T* pend(array);
- while(*pend)
+ while (*pend)
{
++pend;
}
- return(pend - array);
+ return (pend - array);
}
return 0;
@@ -89,14 +90,15 @@ std::size_t compute_array_size2(const T* array)
* specifies the number of elements in the input sequence.
*/
template <class Tr>
-typename Tr::CType* create_array(typename std::vector<typename Tr::CppType>::const_iterator pbegin,
std::size_t size)
+typename Tr::CType*
+create_array(typename std::vector<typename Tr::CppType>::const_iterator pbegin, std::size_t size)
{
typedef typename Tr::CType CType;
- CType *const array(static_cast<CType*>(g_malloc((size + 1) * sizeof(CType))));
- CType *const array_end(array + size);
+ CType* const array(static_cast<CType*>(g_malloc((size + 1) * sizeof(CType))));
+ CType* const array_end(array + size);
- for(CType* pdest(array); pdest != array_end; ++pdest)
+ for (CType* pdest(array); pdest != array_end; ++pdest)
{
// Use & to force a warning if the iterator returns a temporary object.
*pdest = Tr::to_c_type(*&*pbegin);
@@ -110,22 +112,22 @@ typename Tr::CType* create_array(typename std::vector<typename Tr::CppType>::con
/* first class function for bools, because std::vector<bool> is a specialization
* which does not conform to being an STL container.
*/
-gboolean* create_bool_array(std::vector<bool>::const_iterator pbegin,
- std::size_t size);
+gboolean* create_bool_array(std::vector<bool>::const_iterator pbegin, std::size_t size);
/* Create and fill a GList as efficient as possible.
* This requires bidirectional iterators.
*/
template <class Tr>
-GList* create_glist(const typename std::vector<typename Tr::CppType>::const_iterator pbegin,
- typename std::vector<typename Tr::CppType>::const_iterator pend)
+GList*
+create_glist(const typename std::vector<typename Tr::CppType>::const_iterator pbegin,
+ typename std::vector<typename Tr::CppType>::const_iterator pend)
{
GList* head(nullptr);
- while(pend != pbegin)
+ while (pend != pbegin)
{
// Use & to force a warning if the iterator returns a temporary object.
- const void *const item(Tr::to_c_type(*&*--pend));
+ const void* const item(Tr::to_c_type(*&*--pend));
head = g_list_prepend(head, const_cast<void*>(item));
}
@@ -136,15 +138,16 @@ GList* create_glist(const typename std::vector<typename Tr::CppType>::const_iter
* This requires bidirectional iterators.
*/
template <class Tr>
-GSList* create_gslist(const typename std::vector<typename Tr::CppType>::const_iterator pbegin,
- typename std::vector<typename Tr::CppType>::const_iterator pend)
+GSList*
+create_gslist(const typename std::vector<typename Tr::CppType>::const_iterator pbegin,
+ typename std::vector<typename Tr::CppType>::const_iterator pend)
{
GSList* head(nullptr);
- while(pend != pbegin)
+ while (pend != pbegin)
{
// Use & to force a warning if the iterator returns a temporary object.
- const void *const item(Tr::to_c_type(*&*--pend));
+ const void* const item(Tr::to_c_type(*&*--pend));
head = g_slist_prepend(head, const_cast<void*>(item));
}
@@ -153,33 +156,32 @@ GSList* create_gslist(const typename std::vector<typename Tr::CppType>::const_it
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
template <class Tr>
class ArrayIterator
{
public:
- typedef typename Tr::CppType CppType;
- typedef typename Tr::CType CType;
+ typedef typename Tr::CppType CppType;
+ typedef typename Tr::CType CType;
- typedef std::random_access_iterator_tag iterator_category;
- typedef CppType value_type;
- typedef std::ptrdiff_t difference_type;
- typedef value_type reference;
- typedef void pointer;
+ typedef std::random_access_iterator_tag iterator_category;
+ typedef CppType value_type;
+ typedef std::ptrdiff_t difference_type;
+ typedef value_type reference;
+ typedef void pointer;
explicit inline ArrayIterator(const CType* pos);
inline value_type operator*() const;
inline value_type operator[](difference_type offset) const;
- inline ArrayIterator<Tr> & operator++();
+ inline ArrayIterator<Tr>& operator++();
inline const ArrayIterator<Tr> operator++(int);
// All this random access stuff is only there because STL algorithms
// usually have optimized specializations for random access iterators,
// and we don't want to give away efficiency for nothing.
- inline ArrayIterator<Tr>& operator+=(difference_type rhs);
- inline ArrayIterator<Tr>& operator-=(difference_type rhs);
+ inline ArrayIterator<Tr>& operator+=(difference_type rhs);
+ inline ArrayIterator<Tr>& operator-=(difference_type rhs);
inline const ArrayIterator<Tr> operator+(difference_type rhs) const;
inline const ArrayIterator<Tr> operator-(difference_type rhs) const;
inline difference_type operator-(const ArrayIterator<Tr>& rhs) const;
@@ -199,20 +201,20 @@ template <class Tr>
class ListIterator
{
public:
- typedef typename Tr::CppType CppType;
- typedef typename Tr::CType CType;
+ typedef typename Tr::CppType CppType;
+ typedef typename Tr::CType CType;
- typedef std::forward_iterator_tag iterator_category;
- typedef CppType value_type;
- typedef std::ptrdiff_t difference_type;
- typedef value_type reference;
- typedef void pointer;
+ typedef std::forward_iterator_tag iterator_category;
+ typedef CppType value_type;
+ typedef std::ptrdiff_t difference_type;
+ typedef value_type reference;
+ typedef void pointer;
explicit inline ListIterator(const GList* node);
- inline value_type operator*() const;
- inline ListIterator<Tr>& operator++();
- inline const ListIterator<Tr> operator++(int);
+ inline value_type operator*() const;
+ inline ListIterator<Tr>& operator++();
+ inline const ListIterator<Tr> operator++(int);
inline bool operator==(const ListIterator<Tr>& rhs) const;
inline bool operator!=(const ListIterator<Tr>& rhs) const;
@@ -225,20 +227,20 @@ template <class Tr>
class SListIterator
{
public:
- typedef typename Tr::CppType CppType;
- typedef typename Tr::CType CType;
+ typedef typename Tr::CppType CppType;
+ typedef typename Tr::CType CType;
- typedef std::forward_iterator_tag iterator_category;
- typedef CppType value_type;
- typedef std::ptrdiff_t difference_type;
- typedef value_type reference;
- typedef void pointer;
+ typedef std::forward_iterator_tag iterator_category;
+ typedef CppType value_type;
+ typedef std::ptrdiff_t difference_type;
+ typedef value_type reference;
+ typedef void pointer;
explicit inline SListIterator(const GSList* node);
- inline value_type operator*() const;
- inline SListIterator<Tr>& operator++();
- inline const SListIterator<Tr> operator++(int);
+ inline value_type operator*() const;
+ inline SListIterator<Tr>& operator++();
+ inline const SListIterator<Tr> operator++(int);
inline bool operator==(const SListIterator<Tr>& rhs) const;
inline bool operator!=(const SListIterator<Tr>& rhs) const;
@@ -273,8 +275,8 @@ template <typename Tr>
class ArrayKeeper
{
public:
- typedef typename Tr::CppType CppType;
- typedef typename Tr::CType CType;
+ typedef typename Tr::CppType CppType;
+ typedef typename Tr::CType CType;
/** Constructs an ArrayKeeper holding @a array of size @a array_size.
* @a ownership tells what should be destroyed with keeper destruction:
@@ -288,7 +290,8 @@ public:
* @param array_size - length of @a array.
* @param ownership - ownership definition.
*/
- explicit inline ArrayKeeper(const CType* array, std::size_t array_size, Glib::OwnershipType ownership);
+ explicit inline ArrayKeeper(
+ const CType* array, std::size_t array_size, Glib::OwnershipType ownership);
inline ArrayKeeper(const ArrayKeeper& keeper);
~ArrayKeeper() noexcept;
@@ -332,8 +335,8 @@ template <typename Tr>
class GListKeeper
{
public:
- typedef typename Tr::CppType CppType;
- typedef typename Tr::CType CType;
+ typedef typename Tr::CppType CppType;
+ typedef typename Tr::CType CType;
/** Constructs an GListKeeper holding @a glist.
* @a ownership tells what should be destroyed with keeper destruction:
@@ -389,8 +392,8 @@ template <typename Tr>
class GSListKeeper
{
public:
- typedef typename Tr::CppType CppType;
- typedef typename Tr::CType CType;
+ typedef typename Tr::CppType CppType;
+ typedef typename Tr::CType CType;
/** Constructs an GSListKeeper holding @a gslist.
* @a ownership tells what should be destroyed with keeper destruction:
@@ -432,19 +435,23 @@ private:
* @code
* std::vector<Glib::ustring> PixbufFormat::get_mime_types() const
* {
- * return
Glib::ArrayHandler<Glib::ustring>::array_to_vector(gdk_pixbuf_format_get_mime_types(const_cast<GdkPixbufFormat*>(gobj())),
Glib::OWNERSHIP_DEEP);
+ * return
+ *
Glib::ArrayHandler<Glib::ustring>::array_to_vector(gdk_pixbuf_format_get_mime_types(const_cast<GdkPixbufFormat*>(gobj())),
+ * Glib::OWNERSHIP_DEEP);
* }
* @endcode
* or
* @code
- * void Display::store_clipboard(const Glib::RefPtr<Gdk::Window>& clipboard_window, guint32 time_, const
std::vector<Glib::ustring>& targets)
+ * void Display::store_clipboard(const Glib::RefPtr<Gdk::Window>& clipboard_window, guint32 time_,
+ * const std::vector<Glib::ustring>& targets)
* {
* if (!targets.size ())
* {
* gdk_display_store_clipboard(gobj(),
* Glib::unwrap (clipboard_window),
* time_,
- * Glib::ArrayHandler<Glib::ustring,
AtomUstringTraits>::vector_to_array(targets).data (),
+ * Glib::ArrayHandler<Glib::ustring,
+ * AtomUstringTraits>::vector_to_array(targets).data (),
* targets.size ());
* }
* }
@@ -456,7 +463,7 @@ private:
* const char** array = Glib::ArrayHandler<Glib::ustring>::vector_to_array(vec).data ();
* @endcode
*/
-template <typename T, typename Tr = Glib::Container_Helpers::TypeTraits<T> >
+template <typename T, typename Tr = Glib::Container_Helpers::TypeTraits<T>>
class ArrayHandler
{
public:
@@ -466,8 +473,9 @@ public:
typedef typename Glib::Container_Helpers::ArrayKeeper<Tr> ArrayKeeperType;
typedef typename Glib::Container_Helpers::ArrayIterator<Tr> ArrayIteratorType;
-// maybe think about using C++0x move constructors?
- static VectorType array_to_vector(const CType* array, std::size_t array_size, Glib::OwnershipType
ownership);
+ // maybe think about using C++0x move constructors?
+ static VectorType array_to_vector(
+ const CType* array, std::size_t array_size, Glib::OwnershipType ownership);
static VectorType array_to_vector(const CType* array, Glib::OwnershipType ownership);
static ArrayKeeperType vector_to_array(const VectorType& vector);
};
@@ -479,11 +487,14 @@ public:
typedef gboolean CType;
typedef bool CppType;
typedef std::vector<bool> VectorType;
- typedef Glib::Container_Helpers::ArrayKeeper<Glib::Container_Helpers::TypeTraits<bool> > ArrayKeeperType;
- typedef Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<bool> >
ArrayIteratorType;
-
-// maybe think about using C++0x move constructors?
- static VectorType array_to_vector(const CType* array, std::size_t array_size, Glib::OwnershipType
ownership);
+ typedef Glib::Container_Helpers::ArrayKeeper<Glib::Container_Helpers::TypeTraits<bool>>
+ ArrayKeeperType;
+ typedef Glib::Container_Helpers::ArrayIterator<Glib::Container_Helpers::TypeTraits<bool>>
+ ArrayIteratorType;
+
+ // maybe think about using C++0x move constructors?
+ static VectorType array_to_vector(
+ const CType* array, std::size_t array_size, Glib::OwnershipType ownership);
static VectorType array_to_vector(const CType* array, Glib::OwnershipType ownership);
static ArrayKeeperType vector_to_array(const VectorType& vector);
};
@@ -496,14 +507,16 @@ public:
* @code
* std::vector< Glib::RefPtr<Window> > Window::get_children()
* {
- * return Glib::ListHandler<Glib::RefPtr<Window> >::list_to_vector(gdk_window_get_children(gobj()),
Glib::OWNERSHIP_SHALLOW);
+ * return Glib::ListHandler<Glib::RefPtr<Window>
+ * >::list_to_vector(gdk_window_get_children(gobj()), Glib::OWNERSHIP_SHALLOW);
* }
* @endcode
* or
* @code
* void Window::set_icon_list(const std::vector< Glib::RefPtr<Gdk::Pixbuf> >& pixbufs)
* {
- * gdk_window_set_icon_list(gobj(), Glib::ListHandler<Glib::RefPtr<Gdk::Pixbuf>
::vector_to_list(pixbufs).data ());
+ * gdk_window_set_icon_list(gobj(), Glib::ListHandler<Glib::RefPtr<Gdk::Pixbuf>
+ * >::vector_to_list(pixbufs).data ());
* }
* @endcode
* Note that usage below is wrong - data() returns a pointer to data owned by
@@ -513,7 +526,7 @@ public:
* GList* glist = Glib::ListHandler<Glib::RefPtr<Gdk::Pixbuf> >::vector_to_list(pixbufs).data();
* @endcode
*/
-template <typename T, typename Tr = Glib::Container_Helpers::TypeTraits<T> >
+template <typename T, typename Tr = Glib::Container_Helpers::TypeTraits<T>>
class ListHandler
{
public:
@@ -523,7 +536,7 @@ public:
typedef typename Glib::Container_Helpers::GListKeeper<Tr> GListKeeperType;
typedef typename Glib::Container_Helpers::ListIterator<Tr> ListIteratorType;
-// maybe think about using C++0x move constructors?
+ // maybe think about using C++0x move constructors?
static VectorType list_to_vector(GList* glist, Glib::OwnershipType ownership);
static GListKeeperType vector_to_list(const VectorType& vector);
};
@@ -536,7 +549,8 @@ public:
* @code
* std::vector< Glib::RefPtr<Display> > DisplayManager::list_displays()
* {
- * return Glib::SListHandler<Glib::RefPtr<Display>
::slist_to_vector(gdk_display_manager_list_displays(gobj()), Glib::OWNERSHIP_SHALLOW);
+ * return Glib::SListHandler<Glib::RefPtr<Display>
+ * >::slist_to_vector(gdk_display_manager_list_displays(gobj()), Glib::OWNERSHIP_SHALLOW);
* }
* @endcode
* or
@@ -553,7 +567,7 @@ public:
* GSList* gslist = Glib::SListHandler< Glib::RefPtr<Display> >::vector_to_slist(vec).data();
* @endcode
*/
-template <typename T, typename Tr = Glib::Container_Helpers::TypeTraits<T> >
+template <typename T, typename Tr = Glib::Container_Helpers::TypeTraits<T>>
class SListHandler
{
public:
@@ -563,7 +577,7 @@ public:
typedef typename Glib::Container_Helpers::GSListKeeper<Tr> GSListKeeperType;
typedef typename Glib::Container_Helpers::SListIterator<Tr> SListIteratorType;
-// maybe think about using C++0x move constructors?
+ // maybe think about using C++0x move constructors?
static VectorType slist_to_vector(GSList* gslist, Glib::OwnershipType ownership);
static GSListKeeperType vector_to_slist(const VectorType& vector);
};
@@ -579,209 +593,212 @@ namespace Container_Helpers
/**** Glib::Container_Helpers::ArrayIterator<> ***********************/
-template <class Tr> inline
-ArrayIterator<Tr>::ArrayIterator(const CType* pos)
-:
- pos_(pos)
-{}
+template <class Tr>
+inline ArrayIterator<Tr>::ArrayIterator(const CType* pos) : pos_(pos)
+{
+}
-template <class Tr> inline
-typename ArrayIterator<Tr>::value_type ArrayIterator<Tr>::operator*() const
+template <class Tr>
+inline typename ArrayIterator<Tr>::value_type ArrayIterator<Tr>::operator*() const
{
return Tr::to_cpp_type(*pos_);
}
-template <class Tr> inline
-typename ArrayIterator<Tr>::value_type
-ArrayIterator<Tr>::operator[](difference_type offset) const
+template <class Tr>
+inline
+ typename ArrayIterator<Tr>::value_type ArrayIterator<Tr>::operator[](difference_type offset) const
{
return Tr::to_cpp_type(pos_[offset]);
}
-template <class Tr> inline
-ArrayIterator<Tr>& ArrayIterator<Tr>::operator++()
+template <class Tr>
+inline ArrayIterator<Tr>& ArrayIterator<Tr>::operator++()
{
++pos_;
return *this;
}
-template <class Tr> inline
-const ArrayIterator<Tr> ArrayIterator<Tr>::operator++(int)
+template <class Tr>
+inline const ArrayIterator<Tr> ArrayIterator<Tr>::operator++(int)
{
return ArrayIterator<Tr>(pos_++);
}
-template <class Tr> inline
-ArrayIterator<Tr>&
+template <class Tr>
+inline ArrayIterator<Tr>&
ArrayIterator<Tr>::operator+=(typename ArrayIterator<Tr>::difference_type rhs)
{
pos_ += rhs;
return *this;
}
-template <class Tr> inline
-ArrayIterator<Tr>&
+template <class Tr>
+inline ArrayIterator<Tr>&
ArrayIterator<Tr>::operator-=(typename ArrayIterator<Tr>::difference_type rhs)
{
pos_ -= rhs;
return *this;
}
-template <class Tr> inline
-const ArrayIterator<Tr>
+template <class Tr>
+inline const ArrayIterator<Tr>
ArrayIterator<Tr>::operator+(typename ArrayIterator<Tr>::difference_type rhs) const
{
return ArrayIterator<Tr>(pos_ + rhs);
}
-template <class Tr> inline
-const ArrayIterator<Tr>
+template <class Tr>
+inline const ArrayIterator<Tr>
ArrayIterator<Tr>::operator-(typename ArrayIterator<Tr>::difference_type rhs) const
{
return ArrayIterator<Tr>(pos_ - rhs);
}
-template <class Tr> inline
-typename ArrayIterator<Tr>::difference_type
+template <class Tr>
+inline typename ArrayIterator<Tr>::difference_type
ArrayIterator<Tr>::operator-(const ArrayIterator<Tr>& rhs) const
{
- return(pos_ - rhs.pos_);
+ return (pos_ - rhs.pos_);
}
-template <class Tr> inline
-bool ArrayIterator<Tr>::operator==(const ArrayIterator<Tr>& rhs) const
+template <class Tr>
+inline bool
+ArrayIterator<Tr>::operator==(const ArrayIterator<Tr>& rhs) const
{
- return(pos_ == rhs.pos_);
+ return (pos_ == rhs.pos_);
}
-template <class Tr> inline
-bool ArrayIterator<Tr>::operator!=(const ArrayIterator<Tr>& rhs) const
+template <class Tr>
+inline bool
+ArrayIterator<Tr>::operator!=(const ArrayIterator<Tr>& rhs) const
{
- return(pos_ != rhs.pos_);
+ return (pos_ != rhs.pos_);
}
-template <class Tr> inline
-bool ArrayIterator<Tr>::operator<(const ArrayIterator<Tr>& rhs) const
+template <class Tr>
+inline bool
+ArrayIterator<Tr>::operator<(const ArrayIterator<Tr>& rhs) const
{
- return(pos_ < rhs.pos_);
+ return (pos_ < rhs.pos_);
}
-template <class Tr> inline
-bool ArrayIterator<Tr>::operator>(const ArrayIterator<Tr>& rhs) const
+template <class Tr>
+inline bool
+ArrayIterator<Tr>::operator>(const ArrayIterator<Tr>& rhs) const
{
- return(pos_ > rhs.pos_);
+ return (pos_ > rhs.pos_);
}
-template <class Tr> inline
-bool ArrayIterator<Tr>::operator<=(const ArrayIterator<Tr>& rhs) const
+template <class Tr>
+inline bool
+ArrayIterator<Tr>::operator<=(const ArrayIterator<Tr>& rhs) const
{
- return(pos_ <= rhs.pos_);
+ return (pos_ <= rhs.pos_);
}
-template <class Tr> inline
-bool ArrayIterator<Tr>::operator>=(const ArrayIterator<Tr>& rhs) const
+template <class Tr>
+inline bool
+ArrayIterator<Tr>::operator>=(const ArrayIterator<Tr>& rhs) const
{
- return(pos_ >= rhs.pos_);
+ return (pos_ >= rhs.pos_);
}
/**** Glib::Container_Helpers::ListIterator<> ************************/
-template <class Tr> inline
-ListIterator<Tr>::ListIterator(const GList* node)
-:
- node_(node)
-{}
+template <class Tr>
+inline ListIterator<Tr>::ListIterator(const GList* node) : node_(node)
+{
+}
-template <class Tr> inline
-typename ListIterator<Tr>::value_type ListIterator<Tr>::operator*() const
+template <class Tr>
+inline typename ListIterator<Tr>::value_type ListIterator<Tr>::operator*() const
{
return Tr::to_cpp_type(static_cast<typename Tr::CTypeNonConst>(node_->data));
}
-template <class Tr> inline
-ListIterator<Tr>& ListIterator<Tr>::operator++()
+template <class Tr>
+inline ListIterator<Tr>& ListIterator<Tr>::operator++()
{
node_ = node_->next;
return *this;
}
-template <class Tr> inline
-const ListIterator<Tr> ListIterator<Tr>::operator++(int)
+template <class Tr>
+inline const ListIterator<Tr> ListIterator<Tr>::operator++(int)
{
const ListIterator<Tr> tmp(*this);
node_ = node_->next;
return tmp;
}
-template <class Tr> inline
-bool ListIterator<Tr>::operator==(const ListIterator<Tr>& rhs) const
+template <class Tr>
+inline bool
+ListIterator<Tr>::operator==(const ListIterator<Tr>& rhs) const
{
- return(node_ == rhs.node_);
+ return (node_ == rhs.node_);
}
-template <class Tr> inline
-bool ListIterator<Tr>::operator!=(const ListIterator<Tr>& rhs) const
+template <class Tr>
+inline bool
+ListIterator<Tr>::operator!=(const ListIterator<Tr>& rhs) const
{
- return(node_ != rhs.node_);
+ return (node_ != rhs.node_);
}
/**** Glib::Container_Helpers::SListIterator<> ************************/
-template <class Tr> inline
-SListIterator<Tr>::SListIterator(const GSList* node)
-:
- node_(node)
-{}
+template <class Tr>
+inline SListIterator<Tr>::SListIterator(const GSList* node) : node_(node)
+{
+}
-template <class Tr> inline
-typename SListIterator<Tr>::value_type SListIterator<Tr>::operator*() const
+template <class Tr>
+inline typename SListIterator<Tr>::value_type SListIterator<Tr>::operator*() const
{
return Tr::to_cpp_type(static_cast<typename Tr::CTypeNonConst>(node_->data));
}
-template <class Tr> inline
-SListIterator<Tr>& SListIterator<Tr>::operator++()
+template <class Tr>
+inline SListIterator<Tr>& SListIterator<Tr>::operator++()
{
node_ = node_->next;
return *this;
}
-template <class Tr> inline
-const SListIterator<Tr> SListIterator<Tr>::operator++(int)
+template <class Tr>
+inline const SListIterator<Tr> SListIterator<Tr>::operator++(int)
{
const ListIterator<Tr> tmp(*this);
node_ = node_->next;
return tmp;
}
-template <class Tr> inline
-bool SListIterator<Tr>::operator==(const SListIterator<Tr>& rhs) const
+template <class Tr>
+inline bool
+SListIterator<Tr>::operator==(const SListIterator<Tr>& rhs) const
{
- return(node_ == rhs.node_);
+ return (node_ == rhs.node_);
}
-template <class Tr> inline
-bool SListIterator<Tr>::operator!=(const SListIterator<Tr>& rhs) const
+template <class Tr>
+inline bool
+SListIterator<Tr>::operator!=(const SListIterator<Tr>& rhs) const
{
- return(node_ != rhs.node_);
+ return (node_ != rhs.node_);
}
/**** Glib::Container_Helpers::ArrayKeeper<> ************************/
template <typename Tr>
-inline ArrayKeeper<Tr>::ArrayKeeper(const CType* array, std::size_t array_size, Glib::OwnershipType
ownership)
-:
- array_(const_cast<CType*>(array)),
- array_size_(array_size),
- ownership_(ownership)
-{}
+inline ArrayKeeper<Tr>::ArrayKeeper(
+ const CType* array, std::size_t array_size, Glib::OwnershipType ownership)
+: array_(const_cast<CType*>(array)), array_size_(array_size), ownership_(ownership)
+{
+}
template <typename Tr>
inline ArrayKeeper<Tr>::ArrayKeeper(const ArrayKeeper& keeper)
-:
- array_(keeper.array_),
- array_size_(keeper.array_size_),
- ownership_(keeper.ownership_)
+: array_(keeper.array_), array_size_(keeper.array_size_), ownership_(keeper.ownership_)
{
keeper.ownership_ = Glib::OWNERSHIP_NONE;
}
@@ -789,14 +806,14 @@ inline ArrayKeeper<Tr>::ArrayKeeper(const ArrayKeeper& keeper)
template <typename Tr>
ArrayKeeper<Tr>::~ArrayKeeper() noexcept
{
- if(array_ && ownership_ != Glib::OWNERSHIP_NONE)
+ if (array_ && ownership_ != Glib::OWNERSHIP_NONE)
{
- if(ownership_ != Glib::OWNERSHIP_SHALLOW)
+ if (ownership_ != Glib::OWNERSHIP_SHALLOW)
{
// Deep ownership: release each container element.
- const CType *const array_end(array_ + array_size_);
+ const CType* const array_end(array_ + array_size_);
- for(const CType* p(array_); p != array_end; ++p)
+ for (const CType* p(array_); p != array_end; ++p)
{
Tr::release_c_type(*p);
}
@@ -806,7 +823,8 @@ ArrayKeeper<Tr>::~ArrayKeeper() noexcept
}
template <typename Tr>
-inline typename Tr::CType* ArrayKeeper<Tr>::data() const
+inline typename Tr::CType*
+ArrayKeeper<Tr>::data() const
{
return array_;
}
@@ -815,16 +833,13 @@ inline typename Tr::CType* ArrayKeeper<Tr>::data() const
template <typename Tr>
inline GListKeeper<Tr>::GListKeeper(const GList* glist, Glib::OwnershipType ownership)
-:
- glist_(const_cast<GList*>(glist)),
- ownership_(ownership)
-{}
+: glist_(const_cast<GList*>(glist)), ownership_(ownership)
+{
+}
template <typename Tr>
inline GListKeeper<Tr>::GListKeeper(const GListKeeper& keeper)
-:
- glist_(keeper.glist_),
- ownership_(keeper.ownership_)
+: glist_(keeper.glist_), ownership_(keeper.ownership_)
{
keeper.ownership_ = Glib::OWNERSHIP_NONE;
}
@@ -834,12 +849,12 @@ GListKeeper<Tr>::~GListKeeper() noexcept
{
typedef typename Tr::CTypeNonConst CTypeNonConst;
- if(glist_ && ownership_ != Glib::OWNERSHIP_NONE)
+ if (glist_ && ownership_ != Glib::OWNERSHIP_NONE)
{
- if(ownership_ != Glib::OWNERSHIP_SHALLOW)
+ if (ownership_ != Glib::OWNERSHIP_SHALLOW)
{
// Deep ownership: release each container element.
- for(GList* node = glist_; node; node = node->next)
+ for (GList* node = glist_; node; node = node->next)
{
Tr::release_c_type(static_cast<CTypeNonConst>(node->data));
}
@@ -849,7 +864,8 @@ GListKeeper<Tr>::~GListKeeper() noexcept
}
template <typename Tr>
-inline GList* GListKeeper<Tr>::data() const
+inline GList*
+GListKeeper<Tr>::data() const
{
return glist_;
}
@@ -858,16 +874,13 @@ inline GList* GListKeeper<Tr>::data() const
template <typename Tr>
inline GSListKeeper<Tr>::GSListKeeper(const GSList* gslist, Glib::OwnershipType ownership)
-:
- gslist_(const_cast<GSList*>(gslist)),
- ownership_(ownership)
-{}
+: gslist_(const_cast<GSList*>(gslist)), ownership_(ownership)
+{
+}
template <typename Tr>
inline GSListKeeper<Tr>::GSListKeeper(const GSListKeeper& keeper)
-:
- gslist_(keeper.gslist_),
- ownership_(keeper.ownership_)
+: gslist_(keeper.gslist_), ownership_(keeper.ownership_)
{
keeper.ownership_ = Glib::OWNERSHIP_NONE;
}
@@ -876,12 +889,12 @@ template <typename Tr>
GSListKeeper<Tr>::~GSListKeeper() noexcept
{
typedef typename Tr::CTypeNonConst CTypeNonConst;
- if(gslist_ && ownership_ != Glib::OWNERSHIP_NONE)
+ if (gslist_ && ownership_ != Glib::OWNERSHIP_NONE)
{
- if(ownership_ != Glib::OWNERSHIP_SHALLOW)
+ if (ownership_ != Glib::OWNERSHIP_SHALLOW)
{
// Deep ownership: release each container element.
- for(GSList* node = gslist_; node; node = node->next)
+ for (GSList* node = gslist_; node; node = node->next)
{
Tr::release_c_type(static_cast<CTypeNonConst>(node->data));
}
@@ -891,7 +904,8 @@ GSListKeeper<Tr>::~GSListKeeper() noexcept
}
template <typename Tr>
-inline GSList* GSListKeeper<Tr>::data() const
+inline GSList*
+GSListKeeper<Tr>::data() const
{
return gslist_;
}
@@ -902,7 +916,8 @@ inline GSList* GSListKeeper<Tr>::data() const
template <typename T, class Tr>
typename ArrayHandler<T, Tr>::VectorType
-ArrayHandler<T, Tr>::array_to_vector(const CType* array, std::size_t array_size, Glib::OwnershipType
ownership)
+ArrayHandler<T, Tr>::array_to_vector(
+ const CType* array, std::size_t array_size, Glib::OwnershipType ownership)
{
if (array)
{
@@ -913,7 +928,8 @@ ArrayHandler<T, Tr>::array_to_vector(const CType* array, std::size_t array_size,
#else
VectorType temp;
temp.reserve(array_size);
- Glib::Container_Helpers::fill_container(temp, ArrayIteratorType(array), ArrayIteratorType(array +
array_size));
+ Glib::Container_Helpers::fill_container(
+ temp, ArrayIteratorType(array), ArrayIteratorType(array + array_size));
return temp;
#endif
}
@@ -931,7 +947,8 @@ template <typename T, class Tr>
typename ArrayHandler<T, Tr>::ArrayKeeperType
ArrayHandler<T, Tr>::vector_to_array(const VectorType& vector)
{
- return ArrayKeeperType(Glib::Container_Helpers::create_array<Tr>(vector.begin(), vector.size()),
vector.size(), Glib::OWNERSHIP_SHALLOW);
+ return ArrayKeeperType(Glib::Container_Helpers::create_array<Tr>(vector.begin(), vector.size()),
+ vector.size(), Glib::OWNERSHIP_SHALLOW);
}
/**** Glib::ListHandler<> ************************/
@@ -956,7 +973,8 @@ template <typename T, class Tr>
typename ListHandler<T, Tr>::GListKeeperType
ListHandler<T, Tr>::vector_to_list(const VectorType& vector)
{
- return GListKeeperType(Glib::Container_Helpers::create_glist<Tr>(vector.begin(), vector.end()),
Glib::OWNERSHIP_SHALLOW);
+ return GListKeeperType(Glib::Container_Helpers::create_glist<Tr>(vector.begin(), vector.end()),
+ Glib::OWNERSHIP_SHALLOW);
}
/**** Glib::SListHandler<> ************************/
@@ -972,7 +990,8 @@ SListHandler<T, Tr>::slist_to_vector(GSList* gslist, Glib::OwnershipType ownersh
#else
VectorType temp;
temp.reserve(g_slist_length(gslist));
- Glib::Container_Helpers::fill_container(temp, SListIteratorType(gslist), SListIteratorType(nullptr));
+ Glib::Container_Helpers::fill_container(
+ temp, SListIteratorType(gslist), SListIteratorType(nullptr));
return temp;
#endif
}
@@ -981,12 +1000,12 @@ template <typename T, class Tr>
typename SListHandler<T, Tr>::GSListKeeperType
SListHandler<T, Tr>::vector_to_slist(const VectorType& vector)
{
- return GSListKeeperType(Glib::Container_Helpers::create_gslist<Tr>(vector.begin(), vector.end()),
Glib::OWNERSHIP_SHALLOW);
+ return GSListKeeperType(Glib::Container_Helpers::create_gslist<Tr>(vector.begin(), vector.end()),
+ Glib::OWNERSHIP_SHALLOW);
}
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
} // namespace Glib
-
#endif /* _GLIBMM_VECTORUTILS_H */
diff --git a/glib/glibmm/weakref.h b/glib/glibmm/weakref.h
index d01c658..40da9c7 100644
--- a/glib/glibmm/weakref.h
+++ b/glib/glibmm/weakref.h
@@ -21,7 +21,7 @@
#include <glibmm/refptr.h>
#include <glibmm/objectbase.h>
#include <type_traits> // std::is_base_of<>
-#include <utility> // std::swap<>, std::forward<>
+#include <utility> // std::swap<>, std::forward<>
namespace Glib
{
@@ -40,7 +40,7 @@ namespace Glib
template <typename T_CppObject>
class WeakRef
{
- static_assert(std::is_base_of<Glib::ObjectBase,T_CppObject>::value,
+ static_assert(std::is_base_of<Glib::ObjectBase, T_CppObject>::value,
"Glib::WeakRef can be used only for classes derived from Glib::ObjectBase.");
public:
@@ -172,20 +172,16 @@ private:
}; // end class WeakRef
-
#ifndef DOXYGEN_SHOULD_SKIP_THIS
template <typename T_CppObject>
-WeakRef<T_CppObject>::WeakRef() noexcept
-:
-pCppObject_(nullptr), gobject_(nullptr)
+WeakRef<T_CppObject>::WeakRef() noexcept : pCppObject_(nullptr), gobject_(nullptr)
{
}
template <typename T_CppObject>
-WeakRef<T_CppObject>::WeakRef(const WeakRef& src) noexcept
-:
-pCppObject_(src.pCppObject_), gobject_(nullptr)
+WeakRef<T_CppObject>::WeakRef(const WeakRef& src) noexcept : pCppObject_(src.pCppObject_),
+ gobject_(nullptr)
{
if (pCppObject_)
{
@@ -204,9 +200,8 @@ pCppObject_(src.pCppObject_), gobject_(nullptr)
}
template <typename T_CppObject>
-WeakRef<T_CppObject>::WeakRef(WeakRef&& src) noexcept
-:
-pCppObject_(src.pCppObject_), gobject_(src.gobject_)
+WeakRef<T_CppObject>::WeakRef(WeakRef&& src) noexcept : pCppObject_(src.pCppObject_),
+ gobject_(src.gobject_)
{
src.pCppObject_ = nullptr;
src.gobject_ = nullptr;
@@ -215,10 +210,11 @@ pCppObject_(src.pCppObject_), gobject_(src.gobject_)
// The templated ctor allows copy construction from any object that's
// castable. Thus, it does downcasts:
// base_ref = derived_ref
-template <typename T_CppObject> template <typename T_CastFrom>
+template <typename T_CppObject>
+template <typename T_CastFrom>
WeakRef<T_CppObject>::WeakRef(const WeakRef<T_CastFrom>& src) noexcept
-:
-pCppObject_(src.pCppObject_), gobject_(nullptr)
+ : pCppObject_(src.pCppObject_),
+ gobject_(nullptr)
{
if (pCppObject_)
{
@@ -239,19 +235,20 @@ pCppObject_(src.pCppObject_), gobject_(nullptr)
// The templated ctor allows move construction from any object that's
// castable. Thus, it does downcasts:
// base_ref = std::move(derived_ref)
-template <typename T_CppObject> template <typename T_CastFrom>
-WeakRef<T_CppObject>::WeakRef(WeakRef<T_CastFrom>&& src) noexcept
-:
-pCppObject_(src.pCppObject_), gobject_(src.gobject_)
+template <typename T_CppObject>
+template <typename T_CastFrom>
+WeakRef<T_CppObject>::WeakRef(WeakRef<T_CastFrom>&& src) noexcept : pCppObject_(src.pCppObject_),
+ gobject_(src.gobject_)
{
src.pCppObject_ = nullptr;
src.gobject_ = nullptr;
}
-template <typename T_CppObject> template <typename T_CastFrom>
+template <typename T_CppObject>
+template <typename T_CastFrom>
WeakRef<T_CppObject>::WeakRef(const RefPtr<T_CastFrom>& src) noexcept
-:
-pCppObject_(src.operator->()), gobject_(nullptr)
+ : pCppObject_(src.operator->()),
+ gobject_(nullptr)
{
if (pCppObject_)
{
@@ -271,21 +268,24 @@ WeakRef<T_CppObject>::~WeakRef() noexcept
}
template <class T_CppObject>
-void WeakRef<T_CppObject>::swap(WeakRef& other) noexcept
+void
+WeakRef<T_CppObject>::swap(WeakRef& other) noexcept
{
std::swap(pCppObject_, other.pCppObject_);
std::swap(gobject_, other.gobject_);
}
template <typename T_CppObject>
-WeakRef<T_CppObject>& WeakRef<T_CppObject>::operator=(const WeakRef& src) noexcept
+WeakRef<T_CppObject>&
+WeakRef<T_CppObject>::operator=(const WeakRef& src) noexcept
{
set(src.pCppObject_, src.gobject_);
return *this;
}
template <typename T_CppObject>
-WeakRef<T_CppObject>& WeakRef<T_CppObject>::operator=(WeakRef&& src) noexcept
+WeakRef<T_CppObject>&
+WeakRef<T_CppObject>::operator=(WeakRef&& src) noexcept
{
// See RefPtr for an explanation of the swap() technique to implement
// copy assignment and move assignment.
@@ -298,23 +298,29 @@ WeakRef<T_CppObject>& WeakRef<T_CppObject>::operator=(WeakRef&& src) noexcept
return *this;
}
-template <typename T_CppObject> template <typename T_CastFrom>
-WeakRef<T_CppObject>& WeakRef<T_CppObject>::operator=(const WeakRef<T_CastFrom>& src) noexcept
+template <typename T_CppObject>
+template <typename T_CastFrom>
+WeakRef<T_CppObject>&
+WeakRef<T_CppObject>::operator=(const WeakRef<T_CastFrom>& src) noexcept
{
set(src.pCppObject_, src.gobject_);
return *this;
}
-template <typename T_CppObject> template <typename T_CastFrom>
-WeakRef<T_CppObject>& WeakRef<T_CppObject>::operator=(WeakRef<T_CastFrom>&& src) noexcept
+template <typename T_CppObject>
+template <typename T_CastFrom>
+WeakRef<T_CppObject>&
+WeakRef<T_CppObject>::operator=(WeakRef<T_CastFrom>&& src) noexcept
{
WeakRef<T_CppObject> temp(std::forward<WeakRef<T_CastFrom>>(src));
this->swap(temp);
return *this;
}
-template <typename T_CppObject> template <typename T_CastFrom>
-WeakRef<T_CppObject>& WeakRef<T_CppObject>::operator=(const RefPtr<T_CastFrom>& src) noexcept
+template <typename T_CppObject>
+template <typename T_CastFrom>
+WeakRef<T_CppObject>&
+WeakRef<T_CppObject>::operator=(const RefPtr<T_CastFrom>& src) noexcept
{
T_CppObject* pCppObject = src.operator->();
set(pCppObject, nullptr);
@@ -336,7 +342,8 @@ WeakRef<T_CppObject>::operator bool() const noexcept
}
template <typename T_CppObject>
-RefPtr<T_CppObject> WeakRef<T_CppObject>::get() const noexcept
+RefPtr<T_CppObject>
+WeakRef<T_CppObject>::get() const noexcept
{
RefPtr<T_CppObject> ret;
@@ -357,13 +364,16 @@ RefPtr<T_CppObject> WeakRef<T_CppObject>::get() const noexcept
}
template <typename T_CppObject>
-void WeakRef<T_CppObject>::reset() noexcept
+void
+WeakRef<T_CppObject>::reset() noexcept
{
set(nullptr, nullptr);
}
-template <typename T_CppObject> template <typename T_CastFrom>
-WeakRef<T_CppObject> WeakRef<T_CppObject>::cast_dynamic(const WeakRef<T_CastFrom>& src) noexcept
+template <typename T_CppObject>
+template <typename T_CastFrom>
+WeakRef<T_CppObject>
+WeakRef<T_CppObject>::cast_dynamic(const WeakRef<T_CastFrom>& src) noexcept
{
WeakRef<T_CppObject> ret;
@@ -376,27 +386,31 @@ WeakRef<T_CppObject> WeakRef<T_CppObject>::cast_dynamic(const WeakRef<T_CastFrom
// Don't call dynamic_cast<>() unless we know that the referenced object
// still exists.
- T_CppObject *const pCppObject = dynamic_cast<T_CppObject*>(src.pCppObject_);
+ T_CppObject* const pCppObject = dynamic_cast<T_CppObject*>(src.pCppObject_);
ret.set(pCppObject, nullptr);
g_object_unref(ptr);
return ret;
}
-template <typename T_CppObject> template <typename T_CastFrom>
-WeakRef<T_CppObject> WeakRef<T_CppObject>::cast_static(const WeakRef<T_CastFrom>& src) noexcept
+template <typename T_CppObject>
+template <typename T_CastFrom>
+WeakRef<T_CppObject>
+WeakRef<T_CppObject>::cast_static(const WeakRef<T_CastFrom>& src) noexcept
{
- T_CppObject *const pCppObject = static_cast<T_CppObject*>(src.pCppObject_);
+ T_CppObject* const pCppObject = static_cast<T_CppObject*>(src.pCppObject_);
WeakRef<T_CppObject> ret;
ret.set(pCppObject, src.gobject_);
return ret;
}
-template <typename T_CppObject> template <typename T_CastFrom>
-WeakRef<T_CppObject> WeakRef<T_CppObject>::cast_const(const WeakRef<T_CastFrom>& src) noexcept
+template <typename T_CppObject>
+template <typename T_CastFrom>
+WeakRef<T_CppObject>
+WeakRef<T_CppObject>::cast_const(const WeakRef<T_CastFrom>& src) noexcept
{
- T_CppObject *const pCppObject = const_cast<T_CppObject*>(src.pCppObject_);
+ T_CppObject* const pCppObject = const_cast<T_CppObject*>(src.pCppObject_);
WeakRef<T_CppObject> ret;
ret.set(pCppObject, src.gobject_);
@@ -404,7 +418,8 @@ WeakRef<T_CppObject> WeakRef<T_CppObject>::cast_const(const WeakRef<T_CastFrom>&
}
template <typename T_CppObject>
-void WeakRef<T_CppObject>::set(T_CppObject* pCppObject, GWeakRef* gobject) noexcept
+void
+WeakRef<T_CppObject>::set(T_CppObject* pCppObject, GWeakRef* gobject) noexcept
{
// We must own a strong reference to the underlying GObject while
// calling g_weak_ref_init() or g_weak_ref_set().
@@ -438,8 +453,9 @@ void WeakRef<T_CppObject>::set(T_CppObject* pCppObject, GWeakRef* gobject) noexc
/** Swap the contents of two WeakRef<>.
* @relates Glib::WeakRef
*/
-template <class T_CppObject> inline
-void swap(WeakRef<T_CppObject>& lhs, WeakRef<T_CppObject>& rhs) noexcept
+template <class T_CppObject>
+inline void
+swap(WeakRef<T_CppObject>& lhs, WeakRef<T_CppObject>& rhs) noexcept
{
lhs.swap(rhs);
}
diff --git a/glib/glibmm/wrap.h b/glib/glibmm/wrap.h
index 9b7d141..36dff85 100644
--- a/glib/glibmm/wrap.h
+++ b/glib/glibmm/wrap.h
@@ -31,7 +31,7 @@ class ObjectBase;
class Object;
// Type of the per-class wrap_new() functions.
-typedef Glib::ObjectBase* (*WrapNewFunction) (GObject*);
+typedef Glib::ObjectBase* (*WrapNewFunction)(GObject*);
// Setup and free the structures used by wrap_register().
// Both functions might be called more than once.
@@ -45,41 +45,48 @@ void wrap_register(GType type, WrapNewFunction func);
// or automatically generate a new wrapper if there's none.
Glib::ObjectBase* wrap_auto(GObject* object, bool take_copy = false);
-/** Create a C++ instance of a known C++ type that is mostly closely associated with the GType of the C
object.
+/** Create a C++ instance of a known C++ type that is mostly closely associated with the GType of
+ * the C object.
* @param object The C object which should be placed in a new C++ instance.
- * @param interface_gtype The returned instance will implement this interface. Otherwise it will be NULL.
+ * @param interface_gtype The returned instance will implement this interface. Otherwise it will be
+ * NULL.
*/
Glib::ObjectBase* wrap_create_new_wrapper_for_interface(GObject* object, GType interface_gtype);
// Return the current C++ wrapper instance of the GObject,
// or automatically generate a new wrapper if there's none.
-template<class TInterface>
-TInterface* wrap_auto_interface(GObject* object, bool take_copy = false)
+template <class TInterface>
+TInterface*
+wrap_auto_interface(GObject* object, bool take_copy = false)
{
- if(!object)
+ if (!object)
return nullptr;
// Look up current C++ wrapper instance:
ObjectBase* pCppObject = ObjectBase::_get_current_wrapper(object);
- if(!pCppObject)
+ if (!pCppObject)
{
// There's not already a wrapper: generate a new C++ instance.
- // We use exact_type_only=true avoid creating Glib::Object for interfaces of unknown implementation,
- // because we do not want a C++ object that does not dynamic_cast to the expected interface type.
+ // We use exact_type_only=true avoid creating Glib::Object for interfaces of unknown
+ // implementation,
+ // because we do not want a C++ object that does not dynamic_cast to the expected interface
+ // type.
pCppObject = wrap_create_new_wrapper_for_interface(object, TInterface::get_base_type());
}
- //If no exact wrapper was created,
- //create an instance of the interface,
- //so we at least get the expected type:
+ // If no exact wrapper was created,
+ // create an instance of the interface,
+ // so we at least get the expected type:
TInterface* result = nullptr;
- if(pCppObject)
+ if (pCppObject)
{
result = dynamic_cast<TInterface*>(pCppObject);
- if(!result)
+ if (!result)
{
- g_warning("Glib::wrap_auto_interface(): The C++ instance (%s) does not dynamic_cast to the
interface.\n", typeid(*pCppObject).name());
+ g_warning("Glib::wrap_auto_interface(): The C++ instance (%s) does not dynamic_cast to the "
+ "interface.\n",
+ typeid(*pCppObject).name());
}
}
else
@@ -87,13 +94,13 @@ TInterface* wrap_auto_interface(GObject* object, bool take_copy = false)
// take_copy=true is used where the GTK+ function doesn't do
// an extra ref for us, and always for plain struct members.
- if(take_copy && result)
+ if (take_copy && result)
result->reference();
return result;
}
-#endif //DOXYGEN_SHOULD_SKIP_THIS
+#endif // DOXYGEN_SHOULD_SKIP_THIS
// Get a C++ instance that wraps the C instance.
// This always returns the same C++ instance for the same C instance.
@@ -103,12 +110,12 @@ TInterface* wrap_auto_interface(GObject* object, bool take_copy = false)
/** @relates Glib::Object */
Glib::RefPtr<Glib::Object> wrap(GObject* object, bool take_copy = false);
-
/** Get the underlying C instance from the C++ instance. This is just
* like calling gobj(), but it does its own check for a NULL pointer.
*/
-template <class T> inline
-typename T::BaseObjectType* unwrap(T* ptr)
+template <class T>
+inline typename T::BaseObjectType*
+unwrap(T* ptr)
{
return (ptr) ? ptr->gobj() : nullptr;
}
@@ -116,8 +123,9 @@ typename T::BaseObjectType* unwrap(T* ptr)
/** Get the underlying C instance from the C++ instance. This is just
* like calling gobj(), but it does its own check for a NULL pointer.
*/
-template <class T> inline
-const typename T::BaseObjectType* unwrap(const T* ptr)
+template <class T>
+inline const typename T::BaseObjectType*
+unwrap(const T* ptr)
{
return (ptr) ? ptr->gobj() : nullptr;
}
@@ -125,8 +133,9 @@ const typename T::BaseObjectType* unwrap(const T* ptr)
/** Get the underlying C instance from the C++ instance. This is just
* like calling gobj(), but it does its own check for a NULL pointer.
*/
-template <class T> inline
-typename T::BaseObjectType* unwrap(const Glib::RefPtr<T>& ptr)
+template <class T>
+inline typename T::BaseObjectType*
+unwrap(const Glib::RefPtr<T>& ptr)
{
return (ptr) ? ptr->gobj() : nullptr;
}
@@ -134,8 +143,9 @@ typename T::BaseObjectType* unwrap(const Glib::RefPtr<T>& ptr)
/** Get the underlying C instance from the C++ instance. This is just
* like calling gobj(), but it does its own check for a NULL pointer.
*/
-template <class T> inline
-const typename T::BaseObjectType* unwrap(const Glib::RefPtr<const T>& ptr)
+template <class T>
+inline const typename T::BaseObjectType*
+unwrap(const Glib::RefPtr<const T>& ptr)
{
return (ptr) ? ptr->gobj() : nullptr;
}
@@ -148,8 +158,9 @@ const typename T::BaseObjectType* unwrap(const Glib::RefPtr<const T>& ptr)
* reference or copy. This is just like calling gobj_copy(), but it does its own
* check for a NULL pointer to the underlying C instance.
*/
-template <class T> inline
-typename T::BaseObjectType* unwrap_copy(const T& obj)
+template <class T>
+inline typename T::BaseObjectType*
+unwrap_copy(const T& obj)
{
return obj.gobj() ? obj.gobj_copy() : nullptr;
}
@@ -158,8 +169,9 @@ typename T::BaseObjectType* unwrap_copy(const T& obj)
* reference. This is just like calling gobj_copy(), but it does its own
* check for a NULL pointer.
*/
-template <class T> inline
-typename T::BaseObjectType* unwrap_copy(const Glib::RefPtr<T>& ptr)
+template <class T>
+inline typename T::BaseObjectType*
+unwrap_copy(const Glib::RefPtr<T>& ptr)
{
return (ptr) ? ptr->gobj_copy() : nullptr;
}
@@ -168,14 +180,13 @@ typename T::BaseObjectType* unwrap_copy(const Glib::RefPtr<T>& ptr)
* reference. This is just like calling gobj_copy(), but it does its own
* check for a NULL pointer.
*/
-template <class T> inline
-const typename T::BaseObjectType* unwrap_copy(const Glib::RefPtr<const T>& ptr)
+template <class T>
+inline const typename T::BaseObjectType*
+unwrap_copy(const Glib::RefPtr<const T>& ptr)
{
return (ptr) ? ptr->gobj_copy() : nullptr;
}
} // namespace Glib
-
#endif /* _GLIBMM_WRAP_H */
-
diff --git a/glib/glibmm/wrap_init.h b/glib/glibmm/wrap_init.h
index fe4660e..f53ae41 100644
--- a/glib/glibmm/wrap_init.h
+++ b/glib/glibmm/wrap_init.h
@@ -25,7 +25,6 @@
#include <glibmm/error.h>
-
namespace Glib
{
@@ -33,6 +32,4 @@ void wrap_init();
} // namespace Glib
-
#endif /* _GLIBMM_WRAP_INIT_H */
-
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
