+2.45.40 (unstable):
+
+Glib:
+* RefPtr: Add move constructor and move assignment operator.
+ (Murray Cumming)
+
+Gio:
+* Application: Add the shutdown signal.
+ (Murray Cumming) Bug #752600 (Ben)
+
+Build:
+* C++11: Use noexcept instead of throw().
+ (Murray Cumming)
+* C++11: Use "= delete" instead of private copy constructors/operator=.
+ (Murray Cumming)
+* C++11: Use nullptr instead of 0.
+ (Murray Cumming)
+* C++11: Use the override keyword.
+
+
2.45.31 (unstable):
Glib:
## You should have received a copy of the GNU Lesser General Public License
## along with this library. If not, see <http://www.gnu.org/licenses/>.
-AC_INIT([glibmm], [2.45.31],
+AC_INIT([glibmm], [2.45.40],
[http://bugzilla.gnome.org/enter_bug.cgi?product=glibmm],
[glibmm], [http://www.gtkmm.org/])
AC_PREREQ([2.59])
AC_DEFINE([GIOMM_STATIC_LIB], [1], [Define if giomm is built as a static library])
])
-glibreq='2.0 >= 2.45.3'
+glibreq='2.0 >= 2.45.4'
GLIBMM_MODULES="sigc++-2.0 >= 2.2.10 glib-$glibreq gobject-$glibreq gmodule-$glibreq"
GIOMM_MODULES="$GLIBMM_MODULES gio-$glibreq"
fdstream_error get_error() const;
protected:
- virtual int_type underflow();
- virtual std::streamsize xsgetn(char* dest, std::streamsize num);
- virtual int sync();
- virtual int_type overflow(int_type c);
- virtual std::streamsize xsputn(const char* source, std::streamsize num);
+ int_type underflow() override;
+ std::streamsize xsgetn(char* dest, std::streamsize num) override;
+ int sync() override;
+ int_type overflow(int_type c) override;
+ std::streamsize xsputn(const char* source, std::streamsize num) override;
private:
Glib::RefPtr<Glib::IOChannel> iochannel_;
const std::string& application_name,
AppInfoCreateFlags flags)
{
- GAppInfo* capp_info = 0;
- GError* gerror = 0;
+ GAppInfo* capp_info = nullptr;
+ GError* gerror = nullptr;
capp_info = g_app_info_create_from_commandline(commandline.c_str(),
application_name.c_str(),
std::vector< Glib::RefPtr<Gio::File> > vec;
vec.push_back(file);
- GError* gerror = 0;
+ GError* gerror = nullptr;
bool retvalue = g_app_info_launch(gobj(), Glib::ListHandler<Glib::RefPtr<Gio::File> >::vector_to_list(vec).data (), Glib::unwrap(launch_context), &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
std::vector< Glib::RefPtr<Gio::File> > vec;
vec.push_back(file);
- GError* gerror = 0;
+ GError* gerror = nullptr;
bool retvalue = g_app_info_launch(gobj(), Glib::ListHandler<Glib::RefPtr<Gio::File> >::vector_to_list(vec).data (), 0, &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
std::vector<std::string> vec;
vec.push_back(uri);
- GError* gerror = 0;
+ GError* gerror = nullptr;
bool retvalue = g_app_info_launch_uris(gobj(), Glib::ListHandler<std::string>::vector_to_list(vec).data (), Glib::unwrap(launch_context), &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
std::vector<std::string> vec;
vec.push_back(uri);
- GError* gerror = 0;
+ GError* gerror = nullptr;
bool retvalue = g_app_info_launch_uris(gobj(), Glib::ListHandler<std::string>::vector_to_list(vec).data (), 0, &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
const Gio::Application* get_application() const { return application_; }
gchar get_short_name() const { return short_name_; }
- bool is_filename_option() const { return slot_filename_ != 0; }
+ bool is_filename_option() const { return slot_filename_ != nullptr; }
const Glib::OptionGroup::SlotOptionArgString* get_slot_string() const
{ return slot_string_; }
return false;
}
- const bool has_value = (value != 0);
+ const bool has_value = (value != nullptr);
const OptionArgCallbackData* const option_arg = iterFind->second;
try
{
else
// We ensure that this is null to ensure that it is not used,
// telling GApplication to put the parsed value in the options VariantDict instead.
- array[0].arg_data = 0;
+ array[0].arg_data = nullptr;
g_application_add_main_option_entries(gobj(), array);
}
//#m4 _CONVERSION(`GVariant*', `const Glib::VariantBase&', `Glib::wrap($3, true)')
_WRAP_SIGNAL(void startup(), "startup")
+
+ //TODO: Remove no_default_handler when we can break ABI
+ _WRAP_SIGNAL(void shutdown(), "shutdown", no_default_handler, newin "2,46")
+
_WRAP_SIGNAL(void activate(), "activate")
//We wrap the open signal without _WRAP_SIGNAL(), because we need to change its parameters.
if(base && base->init_finish)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
bool const result = (*base->init_finish)(gobj(), Glib::unwrap(res),
&gerror);
bool DataInputStream::read_line(std::string& line, const Glib::RefPtr<Cancellable>& cancellable)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
char* c_line = g_data_input_stream_read_line(gobj(),
0, // pass NULL since we can easily determine the length from the returned std::string
Glib::unwrap(cancellable),
bool DataInputStream::read_line(std::string& line)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
char* c_line = g_data_input_stream_read_line(gobj(),
0, // pass NULL since we can easily determine the length from the returned std::string
0,
bool DataInputStream::read_line_finish(const Glib::RefPtr<AsyncResult>& result, std::string& data)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
gsize size = 0;
gchar* buffer = g_data_input_stream_read_line_finish(gobj(), Glib::unwrap(result), &size, &(gerror));
if(gerror)
bool retval = false;
if(buffer && size)
{
- retval = (buffer != 0);
+ retval = (buffer != nullptr);
data = std::string(buffer, size);
g_free (buffer);
}
bool DataInputStream::read_until(std::string& data, const std::string& stop_chars, const Glib::RefPtr<Cancellable>& cancellable)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
char* c_str = g_data_input_stream_read_until(gobj(),
stop_chars.c_str(),
0, // pass NULL since we can easily determine the length from the returned std::string
*/
bool DataInputStream::read_until(std::string& data, const std::string& stop_chars)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
char* c_str = g_data_input_stream_read_until(gobj(),
stop_chars.c_str(),
0, // pass NULL since we can easily determine the length from the returned std::string
bool DataInputStream::read_until_finish(const Glib::RefPtr<AsyncResult>& result, std::string& data)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
gsize size = 0;
gchar* buffer = g_data_input_stream_read_until_finish(gobj(), Glib::unwrap(result), &size, &(gerror));
if(gerror)
bool retval = false;
if(buffer && size)
{
- retval = (buffer != 0);
+ retval = (buffer != nullptr);
data = std::string(buffer, size);
g_free (buffer);
}
bool DataInputStream::read_upto(std::string& data, const std::string& stop_chars, const Glib::RefPtr<Cancellable>& cancellable)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
char* c_str = g_data_input_stream_read_upto(gobj(),
stop_chars.c_str(), -1, /* null-terminated */
0, // pass NULL since we can easily determine the length from the returned std::string
*/
bool DataInputStream::read_upto(std::string& data, const std::string& stop_chars)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
char* c_str = g_data_input_stream_read_upto(gobj(),
stop_chars.c_str(), -1, /* null-terminated */
0, // pass NULL since we can easily determine the length from the returned std::string
bool DataInputStream::read_upto_finish(const Glib::RefPtr<AsyncResult>& result, std::string& data)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
gsize size = 0;
gchar* buffer = g_data_input_stream_read_upto_finish(gobj(), Glib::unwrap(result), &size, &(gerror));
if(gerror)
bool retval = false;
if(buffer && size)
{
- retval = (buffer != 0);
+ retval = (buffer != nullptr);
data = std::string(buffer, size);
g_free (buffer);
}
bool is_supported(const std::string& address)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
bool const result = g_dbus_is_supported_address(address.c_str(), &gerror);
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::RefPtr<IOStream> get_stream_finish(const Glib::RefPtr<AsyncResult>& res,
std::string& out_guid)
{
- GError* gerror = 0;
- gchar* g_out_guid = 0;
+ GError* gerror = nullptr;
+ gchar* g_out_guid = nullptr;
auto result =
Glib::wrap(g_dbus_address_get_stream_finish(Glib::unwrap(res),
Glib::RefPtr<IOStream> get_stream_finish(const Glib::RefPtr<AsyncResult>& res)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto result =
Glib::wrap(g_dbus_address_get_stream_finish(Glib::unwrap(res), 0,
Glib::RefPtr<IOStream> get_stream_sync(const std::string& address,
const Glib::RefPtr<Cancellable>& cancellable, std::string& out_guid)
{
- GError* gerror = 0;
- gchar* g_out_guid = 0;
+ GError* gerror = nullptr;
+ gchar* g_out_guid = nullptr;
auto result =
Glib::wrap(g_dbus_address_get_stream_sync(address.c_str(),
Glib::RefPtr<IOStream> get_stream_sync(const std::string& address,
std::string& out_guid)
{
- GError* gerror = 0;
- gchar* g_out_guid = 0;
+ GError* gerror = nullptr;
+ gchar* g_out_guid = nullptr;
auto result =
Glib::wrap(g_dbus_address_get_stream_sync(address.c_str(),
Glib::RefPtr<IOStream> get_stream_sync(const std::string& address,
const Glib::RefPtr<Cancellable>& cancellable)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto result =
Glib::wrap(g_dbus_address_get_stream_sync(address.c_str(), 0,
Glib::RefPtr<IOStream> get_stream_sync(const std::string& address)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto result =
Glib::wrap(g_dbus_address_get_stream_sync(address.c_str(), 0, 0, &gerror));
std::string get_for_bus_sync(BusType bus_type,
const Glib::RefPtr<Cancellable>& cancellable)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
std::string result(g_dbus_address_get_for_bus_sync(
static_cast<GBusType>(bus_type), Glib::unwrap(cancellable), &gerror));
std::string get_for_bus_sync(BusType bus_type)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
std::string result(g_dbus_address_get_for_bus_sync(
static_cast<GBusType>(bus_type), 0, &gerror));
bool Connection::send_message(const Glib::RefPtr<Message>& message,
SendMessageFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
const bool result = g_dbus_connection_send_message(gobj(),
Glib::unwrap(message), static_cast<GDBusSendMessageFlags>(flags), 0,
gint timeout_msec)
{
volatile guint32 out_serial = 0;
- GError* gerror = 0;
+ GError* gerror = nullptr;
GDBusMessage* result =
g_dbus_connection_send_message_with_reply_sync(gobj(),
gint timeout_msec)
{
volatile guint32 out_serial = 0;
- GError* gerror = 0;
+ GError* gerror = nullptr;
GDBusMessage* result =
g_dbus_connection_send_message_with_reply_sync(gobj(),
CallFlags flags,
const Glib::VariantType& reply_type)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
GVariant* const gvariant =
g_dbus_connection_call_sync(gobj(), bus_name.c_str(), object_path.c_str(),
CallFlags flags,
const Glib::VariantType& reply_type)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
GVariant* const gvariant =
g_dbus_connection_call_sync(gobj(), bus_name.c_str(), object_path.c_str(),
const Glib::ustring& destination_bus_name,
const Glib::VariantContainerBase& parameters)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
// Strings are checked to see if they are empty so that NULL can be passed
// for those strings to the C API. This is done because some strings such as
const Glib::RefPtr<InterfaceInfo>& interface_info,
const InterfaceVTable& vtable)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
const guint result = g_dbus_connection_register_object(gobj(),
object_path.c_str(), Glib::unwrap(interface_info),
guint Connection::register_object(const Glib::ustring& object_path,
const Glib::RefPtr<InterfaceInfo>& interface_info)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
const guint result = g_dbus_connection_register_object(gobj(),
object_path.c_str(), Glib::unwrap(interface_info),
guint Connection::register_subtree(const Glib::ustring& object_path,
const SubtreeVTable& vtable, SubtreeFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
const guint result = g_dbus_connection_register_subtree(gobj(),
object_path.c_str(),
CallFlags flags
)
{
- GError* g_error = 0;
+ GError* g_error = nullptr;
GVariant* const gvariant =
g_dbus_proxy_call_sync(gobj(), method_name.c_str(),
CallFlags flags
)
{
- GError* g_error = 0;
+ GError* g_error = nullptr;
GVariant* const gvariant =
g_dbus_proxy_call_sync(gobj(), method_name.c_str(),
Glib::RefPtr<FileInfo> File::query_info(const Glib::RefPtr<Cancellable>& cancellable, const std::string& attributes, FileQueryInfoFlags flags) const
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = Glib::wrap(g_file_query_info(const_cast<GFile*>(gobj()), attributes.c_str(), ((GFileQueryInfoFlags)(flags)), const_cast<GCancellable*>(Glib::unwrap(cancellable)), &(gerror)));
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::RefPtr<FileInfo> File::query_info(const std::string& attributes, FileQueryInfoFlags flags) const
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = Glib::wrap(g_file_query_info(const_cast<GFile*>(gobj()), attributes.c_str(), ((GFileQueryInfoFlags)(flags)), 0, &(gerror)));
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::RefPtr<FileInfo> File::query_filesystem_info(const Glib::RefPtr<Cancellable>& cancellable, const std::string& attributes)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = Glib::wrap(g_file_query_filesystem_info(gobj(), attributes.c_str(), const_cast<GCancellable*>(Glib::unwrap(cancellable)), &(gerror)));
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::RefPtr<FileInfo> File::query_filesystem_info(const std::string& attributes)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = Glib::wrap(g_file_query_filesystem_info(gobj(), attributes.c_str(), 0, &(gerror)));
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::RefPtr<FileEnumerator> File::enumerate_children(const Glib::RefPtr<Cancellable>& cancellable, const std::string& attributes, FileQueryInfoFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = Glib::wrap(g_file_enumerate_children(gobj(), attributes.c_str(), ((GFileQueryInfoFlags)(flags)), const_cast<GCancellable*>(Glib::unwrap(cancellable)), &(gerror)));
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::RefPtr<FileEnumerator> File::enumerate_children(const std::string& attributes, FileQueryInfoFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = Glib::wrap(g_file_enumerate_children(gobj(), attributes.c_str(), ((GFileQueryInfoFlags)(flags)), 0, &(gerror)));
if(gerror)
::Glib::Error::throw_exception(gerror);
bool
File::copy(const Glib::RefPtr<File>& destination, const SlotFileProgress& slot, const Glib::RefPtr<Cancellable>& cancellable, FileCopyFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
bool res;
// Create a copy of the slot.
bool
File::copy(const Glib::RefPtr<File>& destination, const SlotFileProgress& slot, FileCopyFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
bool res;
// Create a copy of the slot.
bool
File::copy(const Glib::RefPtr<File>& destination, FileCopyFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
bool res = g_file_copy(gobj(),
Glib::unwrap(destination),
static_cast<GFileCopyFlags>(flags),
bool
File::move(const Glib::RefPtr<File>& destination, const SlotFileProgress& slot, const Glib::RefPtr<Cancellable>& cancellable, FileCopyFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
bool res;
// Create a move of the slot.
bool
File::move(const Glib::RefPtr<File>& destination, const SlotFileProgress& slot, FileCopyFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
bool res;
// Create a move of the slot.
bool
File::move(const Glib::RefPtr<File>& destination, FileCopyFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
bool res;
res = g_file_move(gobj(),
File::set_attributes_finish(const Glib::RefPtr<AsyncResult>& result,
const Glib::RefPtr<FileInfo>& info)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
GFileInfo* cinfo = Glib::unwrap(info);
bool res;
void File::replace_contents(const char* contents, gsize length, const std::string& etag, std::string& new_etag, const Glib::RefPtr<Cancellable>& cancellable, bool make_backup, FileCreateFlags flags)
{
- GError* gerror = 0;
- gchar* c_etag_new = 0;
+ GError* gerror = nullptr;
+ gchar* c_etag_new = nullptr;
g_file_replace_contents(gobj(), contents, length, etag.empty() ? 0 : etag.c_str(), static_cast<int>(make_backup), ((GFileCreateFlags)(flags)), &c_etag_new, const_cast<GCancellable*>(Glib::unwrap(cancellable)), &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
void File::replace_contents(const char* contents, gsize length, const std::string& etag, std::string& new_etag, bool make_backup, FileCreateFlags flags)
{
- GError* gerror = 0;
- gchar* c_etag_new = 0;
+ GError* gerror = nullptr;
+ gchar* c_etag_new = nullptr;
g_file_replace_contents(gobj(), contents, length, etag.empty() ? 0 : etag.c_str(), static_cast<int>(make_backup), ((GFileCreateFlags)(flags)), &c_etag_new, 0, &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
void File::replace_contents(const std::string& contents, const std::string& etag, std::string& new_etag, const Glib::RefPtr<Cancellable>& cancellable, bool make_backup, FileCreateFlags flags)
{
- GError* gerror = 0;
- gchar* c_etag_new = 0;
+ GError* gerror = nullptr;
+ gchar* c_etag_new = nullptr;
g_file_replace_contents(gobj(), contents.c_str(), contents.size(), etag.empty() ? 0 : etag.c_str(), static_cast<int>(make_backup), ((GFileCreateFlags)(flags)), &c_etag_new, const_cast<GCancellable*>(Glib::unwrap(cancellable)), &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
void File::replace_contents(const std::string& contents, const std::string& etag, std::string& new_etag, bool make_backup, FileCreateFlags flags)
{
- GError* gerror = 0;
- gchar* c_etag_new = 0;
+ GError* gerror = nullptr;
+ gchar* c_etag_new = nullptr;
g_file_replace_contents(gobj(), contents.c_str(), contents.size(), etag.empty() ? 0 : etag.c_str(), static_cast<int>(make_backup), ((GFileCreateFlags)(flags)), &c_etag_new, 0, &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
void File::replace_contents_finish(const Glib::RefPtr<AsyncResult>& result, std::string& new_etag)
{
- GError* gerror = 0;
- gchar* c_new_etag = 0;
+ GError* gerror = nullptr;
+ gchar* c_new_etag = nullptr;
g_file_replace_contents_finish(gobj(), Glib::unwrap(result), &c_new_etag, &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
void File::replace_contents_finish(const Glib::RefPtr<AsyncResult>& result)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
g_file_replace_contents_finish(gobj(), Glib::unwrap(result), 0, &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::RefPtr<FileOutputStream> File::replace(const Glib::RefPtr<Cancellable>& cancellable, const std::string& etag, bool make_backup, FileCreateFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = Glib::wrap(g_file_replace(gobj(), etag.empty() ? 0 : etag.c_str(), static_cast<int>(make_backup), ((GFileCreateFlags)(flags)), const_cast<GCancellable*>(Glib::unwrap(cancellable)), &(gerror)));
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::RefPtr<FileOutputStream> File::replace(const std::string& etag, bool make_backup, FileCreateFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = Glib::wrap(g_file_replace(gobj(), etag.empty() ? 0 : etag.c_str(), static_cast<int>(make_backup), ((GFileCreateFlags)(flags)), 0, &(gerror)));
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::RefPtr<FileIOStream> File::replace_readwrite(const Glib::RefPtr<Cancellable>& cancellable, const std::string& etag, bool make_backup, FileCreateFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = Glib::wrap(g_file_replace_readwrite(gobj(), etag.empty() ? 0 : etag.c_str(), static_cast<int>(make_backup), ((GFileCreateFlags)(flags)), const_cast<GCancellable*>(Glib::unwrap(cancellable)), &(gerror)));
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::RefPtr<FileIOStream> File::replace_readwrite(const std::string& etag, bool make_backup, FileCreateFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = Glib::wrap(g_file_replace_readwrite(gobj(), etag.empty() ? 0 : etag.c_str(), static_cast<int>(make_backup), ((GFileCreateFlags)(flags)), 0, &(gerror)));
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::RefPtr<FileMonitor> File::monitor_directory(const Glib::RefPtr<Cancellable>& cancellable, FileMonitorFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = Glib::wrap(g_file_monitor_directory(gobj(), ((GFileMonitorFlags)(flags)), const_cast<GCancellable*>(Glib::unwrap(cancellable)), &(gerror)));
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::RefPtr<FileMonitor> File::monitor_directory(FileMonitorFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = Glib::wrap(g_file_monitor_directory(gobj(), ((GFileMonitorFlags)(flags)), 0, &(gerror)));
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::RefPtr<FileMonitor> File::monitor_file(const Glib::RefPtr<Cancellable>& cancellable, FileMonitorFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = Glib::wrap(g_file_monitor_file(gobj(), ((GFileMonitorFlags)(flags)), const_cast<GCancellable*>(Glib::unwrap(cancellable)), &(gerror)));
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::RefPtr<FileMonitor> File::monitor_file(FileMonitorFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = Glib::wrap(g_file_monitor_file(gobj(), ((GFileMonitorFlags)(flags)), 0, &(gerror)));
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::RefPtr<FileMonitor> File::monitor(const Glib::RefPtr<Cancellable>& cancellable, FileMonitorFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = Glib::wrap(g_file_monitor(gobj(), ((GFileMonitorFlags)(flags)), const_cast<GCancellable*>(Glib::unwrap(cancellable)), &(gerror)));
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::RefPtr<FileMonitor> File::monitor(FileMonitorFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = Glib::wrap(g_file_monitor(gobj(), ((GFileMonitorFlags)(flags)), 0, &(gerror)));
if(gerror)
::Glib::Error::throw_exception(gerror);
void File::measure_disk_usage(const Glib::RefPtr<Cancellable>& cancellable, const SlotFileMeasureProgress& slot_progress, guint64& disk_usage, guint64& num_dirs, guint64& num_files, FileMeasureFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
g_file_measure_disk_usage(gobj(), ((GFileMeasureFlags)(flags)),
const_cast<GCancellable*>(Glib::unwrap(cancellable)),
&SignalProxy_file_measure_progress_callback, const_cast<SlotFileMeasureProgress*>(&slot_progress),
bool File::set_attributes_from_info(const Glib::RefPtr<FileInfo>& info, const Glib::RefPtr<Cancellable>& cancellable, FileQueryInfoFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
bool retvalue = g_file_set_attributes_from_info(gobj(), Glib::unwrap(info), ((GFileQueryInfoFlags)(flags)), const_cast<GCancellable*>(Glib::unwrap(cancellable)), &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
bool File::set_attributes_from_info(const Glib::RefPtr<FileInfo>& info, FileQueryInfoFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
bool retvalue = g_file_set_attributes_from_info(gobj(), Glib::unwrap(info), ((GFileQueryInfoFlags)(flags)), 0, &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
bool
File::copy_attributes(const Glib::RefPtr<File>& destination, const Glib::RefPtr<Cancellable>& cancellable, FileCopyFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
bool res;
res = g_file_copy_attributes(gobj(),
bool
File::copy_attributes(const Glib::RefPtr<File>& destination, FileCopyFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
bool res;
res = g_file_copy_attributes(gobj(),
Glib::RefPtr<FileOutputStream> File::create_file(const Glib::RefPtr<Cancellable>& cancellable, FileCreateFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = Glib::wrap(g_file_create(gobj(), ((GFileCreateFlags)(flags)), const_cast<GCancellable*>(Glib::unwrap(cancellable)), &(gerror)));
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::RefPtr<FileOutputStream> File::create_file(FileCreateFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = Glib::wrap(g_file_create(gobj(), ((GFileCreateFlags)(flags)), 0, &(gerror)));
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::RefPtr<FileIOStream> File::create_file_readwrite(const Glib::RefPtr<Cancellable>& cancellable, FileCreateFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = Glib::wrap(g_file_create_readwrite(gobj(), ((GFileCreateFlags)(flags)), const_cast<GCancellable*>(Glib::unwrap(cancellable)), &(gerror)));
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::RefPtr<FileIOStream> File::create_file_readwrite(FileCreateFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = Glib::wrap(g_file_create_readwrite(gobj(), ((GFileCreateFlags)(flags)), 0, &(gerror)));
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::RefPtr<FileOutputStream> File::append_to(const Glib::RefPtr<Cancellable>& cancellable, FileCreateFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = Glib::wrap(g_file_append_to(gobj(), ((GFileCreateFlags)(flags)), const_cast<GCancellable*>(Glib::unwrap(cancellable)), &(gerror)));
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::RefPtr<FileOutputStream> File::append_to(FileCreateFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = Glib::wrap(g_file_append_to(gobj(), ((GFileCreateFlags)(flags)), 0, &(gerror)));
if(gerror)
::Glib::Error::throw_exception(gerror);
bool File::load_contents(const Glib::RefPtr<Cancellable>& cancellable, char*& contents, gsize& length, std::string& etag_out)
{
- GError* gerror = 0;
- gchar* cetag_out = 0;
+ GError* gerror = nullptr;
+ gchar* cetag_out = nullptr;
bool retvalue = g_file_load_contents(gobj(), Glib::unwrap(cancellable), &contents, &(length), &cetag_out, &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
bool File::load_contents(const Glib::RefPtr<Cancellable>& cancellable, char*& contents, gsize& length)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
bool retvalue = g_file_load_contents(gobj(), Glib::unwrap(cancellable), &contents, &(length), 0, &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
bool File::load_contents(char*& contents, gsize& length, std::string& etag_out)
{
- GError* gerror = 0;
- gchar* cetag_out = 0;
+ GError* gerror = nullptr;
+ gchar* cetag_out = nullptr;
bool retvalue = g_file_load_contents(gobj(), 0, &contents, &(length), &cetag_out, &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
bool File::load_contents(char*& contents, gsize& length)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
bool retvalue = g_file_load_contents(gobj(), 0, &contents, &(length), 0, &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
bool File::load_contents_finish(const Glib::RefPtr<AsyncResult>& result, char*& contents, gsize& length, std::string& etag_out)
{
- GError* gerror = 0;
- gchar* cetag_out = 0;
+ GError* gerror = nullptr;
+ gchar* cetag_out = nullptr;
bool retvalue = g_file_load_contents_finish(gobj(), Glib::unwrap(result), &contents, &(length), &cetag_out, &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
bool File::load_contents_finish(const Glib::RefPtr<AsyncResult>& result, char*& contents, gsize& length)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
bool retvalue = g_file_load_contents_finish(gobj(), Glib::unwrap(result), &contents, &(length), 0, &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
bool File::load_partial_contents_finish(const Glib::RefPtr<AsyncResult>& result, char*& contents, gsize& length, std::string& etag_out)
{
- GError* gerror = 0;
- gchar* cetag_out = 0;
+ GError* gerror = nullptr;
+ gchar* cetag_out = nullptr;
bool retvalue = g_file_load_partial_contents_finish(gobj(), Glib::unwrap(result), &contents, &(length), &cetag_out, &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
bool File::load_partial_contents_finish(const Glib::RefPtr<AsyncResult>& result, char*& contents, gsize& length)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
bool retvalue = g_file_load_partial_contents_finish(gobj(), Glib::unwrap(result), &contents, &(length), 0, &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
bool FileAttributeInfoList::empty() const
{
- return gobj() == 0;
+ return gobj() == nullptr;
}
FileAttributeInfo
Glib::RefPtr<FileInfo> FileInputStream::query_info(const Glib::RefPtr<Cancellable>& cancellable, const std::string& attributes)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = Glib::wrap(g_file_input_stream_query_info(gobj(), g_strdup((attributes).c_str()), const_cast<GCancellable*>(Glib::unwrap(cancellable)), &(gerror)));
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::RefPtr<FileInfo> FileInputStream::query_info(const std::string& attributes)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = Glib::wrap(g_file_input_stream_query_info(gobj(), g_strdup((attributes).c_str()), 0, &(gerror)));
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::RefPtr<FileInfo> FileIOStream::query_info(const Glib::RefPtr<Cancellable>& cancellable, const std::string& attributes)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = Glib::wrap(g_file_io_stream_query_info(gobj(), g_strdup((attributes).c_str()), const_cast<GCancellable*>(Glib::unwrap(cancellable)), &(gerror)));
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::RefPtr<FileInfo> FileIOStream::query_info(const std::string& attributes)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = Glib::wrap(g_file_io_stream_query_info(gobj(), g_strdup((attributes).c_str()), 0, &(gerror)));
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::RefPtr<FileInfo> FileOutputStream::query_info(const Glib::RefPtr<Cancellable>& cancellable, const std::string& attributes)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = Glib::wrap(g_file_output_stream_query_info(gobj(), g_strdup((attributes).c_str()), const_cast<GCancellable*>(Glib::unwrap(cancellable)), &(gerror)));
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::RefPtr<FileInfo> FileOutputStream::query_info(const std::string& attributes)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = Glib::wrap(g_file_output_stream_query_info(gobj(), g_strdup((attributes).c_str()), 0, &(gerror)));
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::RefPtr<Icon> Icon::create(const std::string& str)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto icon = g_icon_new_for_string(str.c_str(), &gerror);
if(gerror)
::Glib::Error::throw_exception(gerror);
LoadableIcon::load(int size, Glib::ustring& type, const Glib::RefPtr<Cancellable>& cancellable)
{
char* c_type;
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retval =
Glib::wrap(g_loadable_icon_load(gobj(),
size,
LoadableIcon::load(int size, Glib::ustring& type)
{
char* c_type;
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retval =
Glib::wrap(g_loadable_icon_load(gobj(),
size,
void MemoryInputStream::add_data(const void* data, gssize len)
{
- char *data_copy = 0;
+ char *data_copy = nullptr;
// copy the data so that the caller doesn't need to keep the data alive
if (len < 0)
bool MenuAttributeIter::get_next(Glib::ustring& out_name,
Glib::VariantBase& value)
{
- const char* g_out_name = 0;
- GVariant* g_value = 0;
+ const char* g_out_name = nullptr;
+ GVariant* g_value = nullptr;
bool const result = g_menu_attribute_iter_get_next(gobj(), &g_out_name,
&g_value);
void MenuItem::unset_target()
{
- const gchar *action_name = 0;
+ const gchar *action_name = nullptr;
g_menu_item_get_attribute (gobj(), G_MENU_ATTRIBUTE_ACTION, "&s", &action_name);
g_menu_item_set_action_and_target_value(gobj(), action_name, 0);
bool MenuLinkIter::get_next(Glib::ustring& out_link,
Glib::RefPtr<MenuModel>& value)
{
- const char* g_out_link = 0;
- GMenuModel* g_value = 0;
+ const char* g_out_link = nullptr;
+ GMenuModel* g_value = nullptr;
bool const result = g_menu_link_iter_get_next(gobj(), &g_out_link, &g_value);
out_link = g_out_link;
void Mount::guess_content_type_sync(const Glib::RefPtr<Cancellable>& cancellable, bool force_rescan)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
g_mount_guess_content_type_sync(gobj(), force_rescan, Glib::unwrap(cancellable),
&gerror);
if(gerror)
void Mount::guess_content_type_sync(bool force_rescan)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
g_mount_guess_content_type_sync(gobj(), force_rescan, 0, &gerror);
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::RefPtr<NetworkAddress>
NetworkAddress::parse(const std::string& host_and_port, guint16 default_port)
{
- GError *error = 0;
+ GError *error = nullptr;
auto *address = G_NETWORK_ADDRESS
(g_network_address_parse (host_and_port.c_str (), default_port,
&error));
gssize OutputStream::write(const std::string& buffer, const Glib::RefPtr<Cancellable>& cancellable)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
gssize retvalue = g_output_stream_write(gobj(), buffer.data(), buffer.size(), Glib::unwrap(cancellable), &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
gssize OutputStream::write(const std::string& buffer)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
gssize retvalue = g_output_stream_write(gobj(), buffer.data(), buffer.size(), 0, &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
bool OutputStream::write_all(const std::string& buffer, gsize& bytes_written, const Glib::RefPtr<Cancellable>& cancellable)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
bool retvalue = g_output_stream_write_all(gobj(), buffer.data(), buffer.size(), &(bytes_written), Glib::unwrap(cancellable), &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
bool OutputStream::write_all(const std::string& buffer, gsize& bytes_written)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
bool retvalue = g_output_stream_write_all(gobj(), buffer.data(), buffer.size(), &(bytes_written), 0, &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
gssize OutputStream::splice(const Glib::RefPtr<InputStream>& source, const Glib::RefPtr<Cancellable>& cancellable, OutputStreamSpliceFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
gssize retvalue = g_output_stream_splice(gobj(), Glib::unwrap(source), ((GOutputStreamSpliceFlags)(flags)), Glib::unwrap(cancellable), &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
gssize OutputStream::splice(const Glib::RefPtr<InputStream>& source, OutputStreamSpliceFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
gssize retvalue = g_output_stream_splice(gobj(), Glib::unwrap(source), ((GOutputStreamSpliceFlags)(flags)), 0, &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
std::vector<Glib::ustring> ProxyResolver::lookup(const Glib::ustring& uri)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue =
Glib::ArrayHandler<Glib::ustring>::array_to_vector(g_proxy_resolver_lookup(gobj(), uri.c_str(), 0, &(gerror)), Glib::OWNERSHIP_DEEP);
if(gerror)
ResourceFlags& flags, ResourceLookupFlags lookup_flags) const
{
guint32 file_flags = 0;
- GError* gerror = 0;
+ GError* gerror = nullptr;
// Ignore the gboolean return value from g_resource_get_info().
// gerror is set if and only if the return value is FALSE.
g_resource_get_info(const_cast<GResource*>(gobj()), path.c_str(),
void Resource::get_file_exists(const std::string& path, ResourceLookupFlags lookup_flags) const
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
g_resource_get_info(const_cast<GResource*>(gobj()), path.c_str(),
(GResourceLookupFlags)lookup_flags, 0, 0, &gerror);
if (gerror)
ResourceFlags& flags, ResourceLookupFlags lookup_flags)
{
guint32 file_flags = 0;
- GError* gerror = 0;
+ GError* gerror = nullptr;
// Ignore the gboolean return value from g_resources_get_info().
// gerror is set if and only if the return value is FALSE.
g_resources_get_info(path.c_str(),
gssize Socket::receive_from(Glib::RefPtr<SocketAddress>& address, char* buffer, gsize size, const Glib::RefPtr<Cancellable>& cancellable)
{
- GError* gerror = 0;
- GSocketAddress* caddr = 0;
+ GError* gerror = nullptr;
+ GSocketAddress* caddr = nullptr;
auto retvalue = g_socket_receive_from(gobj(), &caddr, buffer, size, const_cast<GCancellable*>(Glib::unwrap(cancellable)), &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
gssize Socket::receive_from(Glib::RefPtr<SocketAddress>& address, char* buffer, gsize size)
{
- GError* gerror = 0;
- GSocketAddress* caddr = 0;
+ GError* gerror = nullptr;
+ GSocketAddress* caddr = nullptr;
auto retvalue = g_socket_receive_from(gobj(), &caddr, buffer, size, 0, &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
gssize Socket::receive_with_blocking(gchar* buffer, gsize size, bool blocking,
const Glib::RefPtr<Cancellable>& cancellable)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
const auto retvalue = g_socket_receive_with_blocking(gobj(), buffer, size,
blocking, Glib::unwrap(cancellable), &(gerror));
if(gerror)
gssize Socket::send_with_blocking(gchar* buffer, gsize size, bool blocking,
const Glib::RefPtr<Cancellable>& cancellable)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
const auto retvalue = g_socket_send_with_blocking(gobj(), buffer, size,
blocking, Glib::unwrap(cancellable), &(gerror));
if(gerror)
bool SocketListener::add_socket(const Glib::RefPtr<Socket>& socket)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
const bool retval = g_socket_listener_add_socket(gobj(),
Glib::unwrap(socket),
0,
bool SocketListener::add_address(const Glib::RefPtr<SocketAddress>& address, SocketType type, SocketProtocol protocol, const Glib::RefPtr<Glib::Object>& source_object, Glib::RefPtr<SocketAddress>& effective_address)
{
- GError* gerror = 0;
- GSocketAddress *retaddr = 0;
+ GError* gerror = nullptr;
+ GSocketAddress *retaddr = nullptr;
const bool retval = g_socket_listener_add_address (gobj(),
Glib::unwrap(address),
static_cast<GSocketType>(type),
bool SocketListener::add_address(const Glib::RefPtr<SocketAddress>& address, SocketType type, SocketProtocol protocol, Glib::RefPtr<SocketAddress>& effective_address)
{
- GError* gerror = 0;
- GSocketAddress *retaddr = 0;
+ GError* gerror = nullptr;
+ GSocketAddress *retaddr = nullptr;
const bool retval = g_socket_listener_add_address (gobj(),
Glib::unwrap(address),
static_cast<GSocketType>(type),
bool SocketListener::add_inet_port(guint16 port)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
const bool retvalue = g_socket_listener_add_inet_port(gobj(), port, 0, &gerror);
if(gerror)
::Glib::Error::throw_exception(gerror);
guint16 SocketListener::add_any_inet_port()
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
const auto retvalue = g_socket_listener_add_any_inet_port(gobj(), 0, &gerror);
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::RefPtr<Socket> SocketListener::accept_socket(Glib::RefPtr<Glib::Object>& source_object, const Glib::RefPtr<Cancellable>& cancellable)
{
- GError* gerror = 0;
- GObject *retobj = 0;
+ GError* gerror = nullptr;
+ GObject *retobj = nullptr;
auto retvalue = g_socket_listener_accept_socket(gobj(),
&retobj,
Glib::unwrap(cancellable),
Glib::RefPtr<Socket> SocketListener::accept_socket(Glib::RefPtr<Glib::Object>& source_object)
{
- GError* gerror = 0;
- GObject *retobj = 0;
+ GError* gerror = nullptr;
+ GObject *retobj = nullptr;
auto retvalue = g_socket_listener_accept_socket(gobj(),
&retobj,
0,
Glib::RefPtr<Socket> SocketListener::accept_socket(const Glib::RefPtr<Cancellable>& cancellable)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = g_socket_listener_accept_socket(gobj(),
0,
Glib::unwrap(cancellable),
Glib::RefPtr<Socket> SocketListener::accept_socket()
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = g_socket_listener_accept_socket(gobj(),
0,
0,
Glib::RefPtr<Socket> SocketListener::accept_socket_finish(const Glib::RefPtr<AsyncResult>& result, Glib::RefPtr<Glib::Object>& source_object)
{
- GError* gerror = 0;
- GObject *retobj = 0;
+ GError* gerror = nullptr;
+ GObject *retobj = nullptr;
auto retvalue = g_socket_listener_accept_socket_finish(gobj(),
Glib::unwrap(result),
&retobj,
Glib::RefPtr<Socket> SocketListener::accept_socket_finish(const Glib::RefPtr<AsyncResult>& result)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = g_socket_listener_accept_socket_finish(gobj(),
Glib::unwrap(result),
0,
Glib::RefPtr<SocketConnection> SocketListener::accept(Glib::RefPtr<Object>& source_object, const Glib::RefPtr<Cancellable>& cancellable)
{
- GError* gerror = 0;
- GObject *retobj = 0;
+ GError* gerror = nullptr;
+ GObject *retobj = nullptr;
auto retvalue = g_socket_listener_accept(gobj(),
&retobj,
Glib::unwrap(cancellable),
Glib::RefPtr<SocketConnection> SocketListener::accept(Glib::RefPtr<Object>& source_object)
{
- GError* gerror = 0;
- GObject *retobj = 0;
+ GError* gerror = nullptr;
+ GObject *retobj = nullptr;
auto retvalue = g_socket_listener_accept(gobj(),
&retobj,
0,
Glib::RefPtr<SocketConnection> SocketListener::accept(const Glib::RefPtr<Cancellable>& cancellable)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = g_socket_listener_accept(gobj(),
0,
Glib::unwrap(cancellable),
Glib::RefPtr<SocketConnection> SocketListener::accept()
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = g_socket_listener_accept(gobj(),
0,
0,
Glib::RefPtr<SocketConnection> SocketListener::accept_finish(const Glib::RefPtr<AsyncResult>& result, Glib::RefPtr<Glib::Object>& source_object)
{
- GError* gerror = 0;
- GObject *retobj = 0;
+ GError* gerror = nullptr;
+ GObject *retobj = nullptr;
auto retvalue = g_socket_listener_accept_finish(gobj(),
Glib::unwrap(result),
&retobj,
Glib::RefPtr<SocketConnection> SocketListener::accept_finish(const Glib::RefPtr<AsyncResult>& result)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = g_socket_listener_accept_finish(gobj(),
Glib::unwrap(result),
0,
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
+#ifndef GLIBMM_DISABLE_DEPRECATED
+
#include <glibmmconfig.h>
#include <glibmm/sarray.h> /* for backward compatibility */
#include <glib.h>
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+#endif //GLIBMM_DISABLE_DEPRECATED
+
#endif /* _GLIBMM_CONTAINERS_H */
public:
~DispatchNotifier();
+ // noncopyable
+ DispatchNotifier(const DispatchNotifier&) = delete;
+ DispatchNotifier& operator=(const DispatchNotifier&) = delete;
+
static DispatchNotifier* reference_instance(
const Glib::RefPtr<MainContext>& context, const Dispatcher* dispatcher);
static void unreference_instance(
void create_pipe();
bool pipe_io_handler(Glib::IOCondition condition);
bool pipe_is_empty();
-
- // noncopyable
- DispatchNotifier(const DispatchNotifier&);
- DispatchNotifier& operator=(const DispatchNotifier&);
};
/**** Glib::DispatchNotifier ***********************************************/
*/
Dispatcher();
+ // noncopyable
+ Dispatcher(const Dispatcher&) = delete;
+ Dispatcher& operator=(const Dispatcher&) = delete;
+
/** Create new Dispatcher instance using an arbitrary main context.
* @throw Glib::FileError
*/
sigc::signal<void> signal_;
DispatchNotifier* notifier_;
- // noncopyable
- Dispatcher(const Dispatcher&);
- Dispatcher& operator=(const Dispatcher&);
-
#ifndef DOXYGEN_SHOULD_SKIP_THIS
friend class Glib::DispatchNotifier;
#endif
typedef std::map<GQuark,Glib::Error::ThrowFunc> ThrowFuncTable;
-static ThrowFuncTable* throw_func_table = 0;
+static ThrowFuncTable* throw_func_table = nullptr;
} // anonymous namespace
if(gobject_)
{
g_error_free(gobject_);
- gobject_ = 0;
+ gobject_ = nullptr;
}
if(other.gobject_)
{
return *this;
}
-Error::~Error() throw()
+Error::~Error() noexcept
{
if(gobject_)
g_error_free(gobject_);
GQuark Error::domain() const
{
- g_return_val_if_fail(gobject_ != 0, 0);
+ g_return_val_if_fail(gobject_ != nullptr, 0);
return gobject_->domain;
}
int Error::code() const
{
- g_return_val_if_fail(gobject_ != 0, -1);
+ g_return_val_if_fail(gobject_ != nullptr, -1);
return gobject_->code;
}
Glib::ustring Error::what() const
{
- g_return_val_if_fail(gobject_ != 0, "");
- g_return_val_if_fail(gobject_->message != 0, "");
+ g_return_val_if_fail(gobject_ != nullptr, "");
+ g_return_val_if_fail(gobject_->message != nullptr, "");
return gobject_->message;
}
void Error::propagate(GError** dest)
{
g_propagate_error(dest, gobject_);
- gobject_ = 0;
+ gobject_ = nullptr;
}
// static
if(throw_func_table)
{
delete throw_func_table;
- throw_func_table = 0;
+ throw_func_table = nullptr;
}
}
// static
void Error::register_domain(GQuark error_domain, Error::ThrowFunc throw_func)
{
- g_assert(throw_func_table != 0);
+ g_assert(throw_func_table != nullptr);
(*throw_func_table)[error_domain] = throw_func;
}
// static, noreturn
void Error::throw_exception(GError* gobject)
{
- g_assert(gobject != 0);
+ g_assert(gobject != nullptr);
// Just in case Gtk::Main hasn't been instantiated yet.
if(!throw_func_table)
Error(const Error& other);
Error& operator=(const Error& other);
- virtual ~Error() throw();
+ virtual ~Error() noexcept;
GQuark domain() const;
int code() const;
namespace Glib
{
-Exception::~Exception() throw()
+Exception::~Exception() noexcept
{}
Glib::ustring Exception::what() const
class Exception
{
public:
- virtual ~Exception() throw() = 0;
+ virtual ~Exception() noexcept = 0;
virtual Glib::ustring what() const = 0;
};
static void glibmm_exception_warning(const GError* error)
{
- g_assert(error != 0);
+ g_assert(error != nullptr);
g_critical("\n"
"unhandled exception (type Glib::Error) in signal handler:\n"
}
// internal
-void exception_handlers_invoke() throw()
+void exception_handlers_invoke() noexcept
{
// This function will be called from our GLib signal handler proxies
// if an exception has been caught. It's not possible to throw C++
#ifndef DOXYGEN_SHOULD_SKIP_THIS
// internal
-void exception_handlers_invoke() throw();
+void exception_handlers_invoke() noexcept;
#endif //DOXYGEN_SHOULD_SKIP_THIS
} // namespace Glib
}
inline size_type max_size() { return size_type(-1); }
- inline bool empty() { return glist() == 0; }
+ inline bool empty() { return glist() == nullptr; }
inline iterator begin()
{return begin_();}
g_free(iface_props);
}
}
- else // gobject_ == 0
+ else // gobject_ == nullptr
{
// The GObject is not instantiated yet. Add to the custom_interface_classes
// and add the interface in the Glib::Object constructor.
explicit Interface(GObject* castitem);
virtual ~Interface();
+ // noncopyable
+ Interface(const Interface&) = delete;
+ Interface& operator=(const Interface&) = delete;
+
//void add_interface(GType gtype_implementer);
// Hook for translating API
inline GObject* gobj() { return gobject_; }
inline const GObject* gobj() const { return gobject_; }
-
-private:
- // noncopyable
- Interface(const Interface&);
- Interface& operator=(const Interface&);
};
RefPtr<ObjectBase> wrap_interface(GObject* object, bool take_copy = false);
template <class Bi, class Tr>
GList* create_list(Bi pbegin, Bi pend, Tr)
{
- GList* head = 0;
+ GList* head = nullptr;
while(pend != pbegin)
{
template <class For, class Tr>
GList* create_list(For pbegin, Tr)
{
- GList* head = 0;
+ GList* head = nullptr;
while(*pbegin)
{
if(ownership_ != Glib::OWNERSHIP_SHALLOW)
{
// Deep ownership: release each container element.
- for(GList* node = plist_; node != 0; 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
bool ListHandle<T,Tr>::empty() const
{
- return (plist_ == 0);
+ return (plist_ == nullptr);
}
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
if (self->source_)
{
GSource* s = self->source_;
- self->source_ = 0;
+ self->source_ = nullptr;
g_source_destroy(s);
// Destroying the object triggers execution of destroy_notify_handler(),
if (self)
{
// The GLib side is disconnected now, thus the GSource* is no longer valid.
- self->source_ = 0;
+ self->source_ = nullptr;
delete self;
}
*/
static SourceCallbackData* glibmm_source_get_callback_data(GSource* source)
{
- g_return_val_if_fail(source->callback_funcs != 0, 0);
+ g_return_val_if_fail(source->callback_funcs != nullptr, 0);
GSourceFunc func;
- void* user_data = 0;
+ void* user_data = nullptr;
// Retrieve the callback function and data.
(*source->callback_funcs->get)(source->callback_data, source, &func, &user_data);
static gboolean glibmm_iosource_callback(GIOChannel*, GIOCondition condition, void* data)
{
SourceCallbackData *const callback_data = static_cast<SourceCallbackData*>(data);
- g_return_val_if_fail(callback_data->node != 0, 0);
+ g_return_val_if_fail(callback_data->node != nullptr, 0);
try
{
if(gobject_)
{
SourceCallbackData *const data = glibmm_source_get_callback_data(gobject_);
- data->wrapper = 0;
+ data->wrapper = nullptr;
GSource *const tmp_gobject = gobject_;
- gobject_ = 0;
+ gobject_ = nullptr;
g_source_unref(tmp_gobject);
SourceCallbackData *const callback_data = static_cast<SourceCallbackData*>(user_data);
g_return_val_if_fail(callback == &glibmm_dummy_source_callback, 0);
- g_return_val_if_fail(callback_data != 0 && callback_data->node != 0, 0);
+ g_return_val_if_fail(callback_data != nullptr && callback_data->node != nullptr, 0);
try
{
Source *const self = static_cast<Source*>(data);
// gobject_ is already invalid at this point.
- self->gobject_ = 0;
+ self->gobject_ = nullptr;
// No exception checking: if the dtor throws, you're out of luck anyway.
delete self;
sigc::slot_base* Source::get_slot_from_callback_data(void* data)
{
SourceCallbackData* const callback_data = static_cast<SourceCallbackData*>(data);
- g_return_val_if_fail(callback_data->node != 0, 0);
+ g_return_val_if_fail(callback_data->node != nullptr, 0);
return callback_data->node->get_slot();
}
typedef Glib::MainContext CppObjectType;
typedef GMainContext BaseObjectType;
+ // noncopyable
+ MainContext(const MainContext& other) = delete;
+ MainContext& operator=(const MainContext& other) = delete;
+
/** Creates a new MainContext.
* @return The new MainContext.
*/
// Glib::MainContext can neither be constructed nor deleted.
MainContext();
void operator delete(void*, std::size_t);
-
- // noncopyable
- MainContext(const MainContext& other);
- MainContext& operator=(const MainContext& other);
-
};
/** @relates Glib::MainContext */
typedef Glib::Source CppObjectType;
typedef GSource BaseObjectType;
+ // noncopyable
+ Source(const Source&) = delete;
+ Source& operator=(const Source&) = delete;
+
static Glib::RefPtr<Source> create() /* = 0 */;
/** Adds a Source to a context so that it will be executed within that context.
static sigc::slot_base* get_slot_from_connection_node(void* data);
// Used by derived Source classes in other files.
static sigc::slot_base* get_slot_from_callback_data(void* data);
-
-private:
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
- // noncopyable
- Source(const Source&);
- Source& operator=(const Source&);
};
static_cast<GObjectClass*>(g_type_class_ref(glibmm_class.get_type()));
unsigned int n_alloced_params = 0;
- char* collect_error = 0; // output argument of G_VALUE_COLLECT()
+ char* collect_error = nullptr; // output argument of G_VALUE_COLLECT()
for(const char* name = first_property_name;
- name != 0;
+ name != nullptr;
name = va_arg(var_args, char*))
{
GParamSpec *const pspec = g_object_class_find_property(g_class, name);
typedef GObjectClass BaseClassType;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+ // noncopyable
+ Object(const Object&) = delete;
+ Object& operator=(const Object&) = delete;
+
protected:
Object(); //For use by C++-only sub-types.
explicit Object(const Glib::ConstructParams& construct_params);
friend class Glib::Object_Class;
static CppClassType object_class_;
- // noncopyable
- Object(const Object&);
- Object& operator=(const Object&);
-
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
// Glib::Object can not be dynamic because it lacks a float state.
g_warning("(Glib::ObjectBase::~ObjectBase): gobject_ = %p", (void*) gobject_);
#endif
- gobject_ = 0;
+ gobject_ = nullptr;
#ifdef GLIBMM_DEBUG_REFCOUNTING
g_warning("(Glib::ObjectBase::~ObjectBase): before g_object_steal_qdata()");
g_warning("Glib::ObjectBase::destroy_notify_: gobject_ = %p", (void*) gobject_);
#endif
- gobject_ = 0; // Make sure we don't unref it again in the dtor.
+ gobject_ = nullptr; // Make sure we don't unref it again in the dtor.
delete this;
}
bool ObjectBase::is_derived_() const
{
// gtkmmproc-generated classes initialize this to 0 by default.
- return (custom_type_name_ != 0);
+ return (custom_type_name_ != nullptr);
}
void ObjectBase::set_manage()
*/
class GLIBMM_API ObjectBase : virtual public sigc::trackable
{
+public:
+
+ // noncopyable
+ ObjectBase(const ObjectBase&) = delete;
+ ObjectBase& operator=(const ObjectBase&) = delete;
+
protected:
/** This default constructor is called implicitly from the constructor of user-derived
* classes, even if, for instance, Gtk::Button calls a different ObjectBase constructor.
* The C++ language itself ensures that the constructor
* is only invoked once.
*
- * All classes generated by gtkmmproc use this constructor, with custom_type_name = 0,
+ * All classes generated by gtkmmproc use this constructor, with custom_type_name = nullptr,
* which essentially means it's not a custom type. This is used to optimize
* vfunc and signal handler callbacks -- since the C++ virtual methods are
* not overridden, invocation can be skipped.
/// This is for use by gtkmm wrappers only, and not by applications.
//inline bool is_derived_inline_() const
//{
- // return (custom_type_name_ != 0);
+ // return (custom_type_name_ != nullptr);
//}
protected:
#endif //DOXYGEN_SHOULD_SKIP_THIS
private:
- // noncopyable
- ObjectBase(const ObjectBase&);
- ObjectBase& operator=(const ObjectBase&);
#ifndef DOXYGEN_SHOULD_SKIP_THIS
virtual void set_manage(); // calls g_error()
explicit PatternSpec(GPatternSpec* gobject);
~PatternSpec();
+ // noncopyable
+ PatternSpec(const PatternSpec&) = delete;
+ PatternSpec& operator=(const PatternSpec&) = delete;
+
bool match(const Glib::ustring& str) const;
bool match(const Glib::ustring& str, const Glib::ustring& str_reversed) const;
private:
GPatternSpec* gobject_;
-
- // noncopyable
- PatternSpec(const PatternSpec&);
- PatternSpec& operator=(const PatternSpec&);
};
/** @} group PatternMatching */
bool PropertyBase::lookup_property(const Glib::ustring& name)
{
- g_assert(param_spec_ == 0);
+ g_assert(param_spec_ == nullptr);
param_spec_ = g_object_class_find_property(G_OBJECT_GET_CLASS(object_->gobj()), name.c_str());
g_param_spec_ref(param_spec_);
}
- return (param_spec_ != 0);
+ return (param_spec_ != nullptr);
}
void PropertyBase::install_property(GParamSpec* param_spec)
{
- g_return_if_fail(param_spec != 0);
+ g_return_if_fail(param_spec != nullptr);
// Ensure that there would not be id clashes with possible existing
// properties overridden from implemented interfaces if dealing with a custom
const char* PropertyBase::get_name_internal() const
{
const char *const name = g_param_spec_get_name(param_spec_);
- g_return_val_if_fail(name != 0, "");
+ g_return_val_if_fail(name != nullptr, "");
return name;
}
{
public:
+ // noncopyable
+ PropertyBase(const PropertyBase&) = delete;
+ PropertyBase& operator=(const PropertyBase&) = delete;
+
/** Returns the name of the property.
*/
Glib::ustring get_name() const;
const char* get_name_internal() const;
private:
- // noncopyable
- PropertyBase(const PropertyBase&);
- PropertyBase& operator=(const PropertyBase&);
#ifndef DOXYGEN_SHOULD_SKIP_THIS
const GParamSpec *const pParamSpec =
g_object_class_find_property(G_OBJECT_GET_CLASS(obj_->gobj()), property_name_);
- g_return_if_fail(pParamSpec != 0);
+ g_return_if_fail(pParamSpec != nullptr);
Glib::ValueBase value;
value.init(G_PARAM_SPEC_VALUE_TYPE(pParamSpec));
explicit Rand(guint32 seed);
~Rand();
+ // noncopyable
+ Rand(const Rand&) = delete;
+ Rand& operator=(const Rand&) = delete;
+
void set_seed(guint32 seed);
bool get_bool();
private:
GRand* gobject_;
-
- // noncopyable
- Rand(const Rand&);
- Rand& operator=(const Rand&);
};
/** @} group Random */
*
* This increments the shared reference count.
*/
- inline RefPtr(const RefPtr<T_CppObject>& src);
+ inline RefPtr(const RefPtr& src);
+
+ /** Move constructor
+ */
+ inline RefPtr(RefPtr&& src);
/** Copy constructor (from different, but castable type).
*
* done safely without involving a reference/unreference cycle and is
* therefore highly efficient.
*/
- inline void swap(RefPtr<T_CppObject>& other);
+ inline void swap(RefPtr& other);
/// Copy from another RefPtr:
- inline RefPtr<T_CppObject>& operator=(const RefPtr<T_CppObject>& src);
+ inline RefPtr& operator=(const RefPtr& src);
+
+ /// Move assignment operator:
+ inline RefPtr& operator=(RefPtr&& src);
/** Copy from different, but castable type).
*
* Increments the reference count.
*/
template <class T_CastFrom>
- inline RefPtr<T_CppObject>& operator=(const RefPtr<T_CastFrom>& src);
+ inline RefPtr& operator=(const RefPtr<T_CastFrom>& src);
/// Tests whether the RefPtr<> point to the same underlying instance.
- inline bool operator==(const RefPtr<T_CppObject>& src) const;
+ inline bool operator==(const RefPtr& src) const;
/// See operator==().
- inline bool operator!=(const RefPtr<T_CppObject>& src) const;
+ inline bool operator!=(const RefPtr& src) const;
/** Dereferencing.
*
* @endcode
*/
template <class T_CastFrom>
- static inline RefPtr<T_CppObject> cast_dynamic(const RefPtr<T_CastFrom>& src);
+ static inline RefPtr cast_dynamic(const RefPtr<T_CastFrom>& src);
/** Static cast to derived class.
*
* @endcode
*/
template <class T_CastFrom>
- static inline RefPtr<T_CppObject> cast_static(const RefPtr<T_CastFrom>& src);
+ static inline RefPtr cast_static(const RefPtr<T_CastFrom>& src);
/** Cast to non-const.
*
* @endcode
*/
template <class T_CastFrom>
- static inline RefPtr<T_CppObject> cast_const(const RefPtr<T_CastFrom>& src);
+ static inline RefPtr cast_const(const RefPtr<T_CastFrom>& src);
//TODO: Maybe remove these if we replace operator bool() with operator const void* after
//an API/ABI break, as suggested by Daniel Elstner? murrayc.
* is still syntactically possible, but the result is semantically
* wrong, as p1 REL_OP p2 is interpreted as (bool)p1 REL_OP (bool)p2.
*/
- inline bool operator<(const RefPtr<T_CppObject>& src) const;
+ inline bool operator<(const RefPtr& src) const;
/// See operator<().
- inline bool operator<=(const RefPtr<T_CppObject>& src) const;
+ inline bool operator<=(const RefPtr& src) const;
/// See operator<().
- inline bool operator>(const RefPtr<T_CppObject>& src) const;
+ inline bool operator>(const RefPtr& src) const;
/// See operator<().
- inline bool operator>=(const RefPtr<T_CppObject>& src) const;
+ inline bool operator>=(const RefPtr& src) const;
private:
T_CppObject* pCppObject_;
{}
template <class T_CppObject> inline
-RefPtr<T_CppObject>::RefPtr(const RefPtr<T_CppObject>& src)
+RefPtr<T_CppObject>::RefPtr(const RefPtr& src)
:
pCppObject_ (src.pCppObject_)
{
pCppObject_->reference();
}
+template <class T_CppObject> inline
+RefPtr<T_CppObject>::RefPtr(RefPtr&& src)
+:
+ pCppObject_ (src.pCppObject_)
+{
+ src.pCppObject_ = nullptr;
+}
+
// The templated ctor allows copy construction from any object that's
// castable. Thus, it does downcasts:
// base_ref = derived_ref
}
template <class T_CppObject> inline
-void RefPtr<T_CppObject>::swap(RefPtr<T_CppObject>& other)
+void RefPtr<T_CppObject>::swap(RefPtr& other)
{
T_CppObject *const temp = pCppObject_;
pCppObject_ = other.pCppObject_;
}
template <class T_CppObject> inline
-RefPtr<T_CppObject>& RefPtr<T_CppObject>::operator=(const RefPtr<T_CppObject>& src)
+RefPtr<T_CppObject>& RefPtr<T_CppObject>::operator=(const RefPtr& src)
{
// In case you haven't seen the swap() technique to implement copy
// assignment before, here's what it does:
return *this;
}
+template <class T_CppObject> inline
+RefPtr<T_CppObject>& RefPtr<T_CppObject>::operator=(RefPtr&& src)
+{
+ if (pCppObject_)
+ pCppObject_->unreference();
+
+ pCppObject_ = src.pCppObject_;
+ src.pCppObject_ = nullptr;
+
+ //This should work instead, but seems less efficient:
+ //RefPtr<T_CppObject> temp (src);
+ //this->swap(temp);
+ //src.pCppObject_ = nullptr;
+
+ return *this;
+}
+
template <class T_CppObject>
template <class T_CastFrom>
inline
}
template <class T_CppObject> inline
-bool RefPtr<T_CppObject>::operator==(const RefPtr<T_CppObject>& src) const
+bool RefPtr<T_CppObject>::operator==(const RefPtr& src) const
{
return (pCppObject_ == src.pCppObject_);
}
template <class T_CppObject> inline
-bool RefPtr<T_CppObject>::operator!=(const RefPtr<T_CppObject>& src) const
+bool RefPtr<T_CppObject>::operator!=(const RefPtr& src) const
{
return (pCppObject_ != src.pCppObject_);
}
template <class T_CppObject> inline
RefPtr<T_CppObject>::operator bool() const
{
- return (pCppObject_ != 0);
+ return (pCppObject_ != nullptr);
}
#ifndef GLIBMM_DISABLE_DEPRECATED
}
template <class T_CppObject> inline
-bool RefPtr<T_CppObject>::operator<(const RefPtr<T_CppObject>& src) const
+bool RefPtr<T_CppObject>::operator<(const RefPtr& src) const
{
return (pCppObject_ < src.pCppObject_);
}
template <class T_CppObject> inline
-bool RefPtr<T_CppObject>::operator<=(const RefPtr<T_CppObject>& src) const
+bool RefPtr<T_CppObject>::operator<=(const RefPtr& src) const
{
return (pCppObject_ <= src.pCppObject_);
}
template <class T_CppObject> inline
-bool RefPtr<T_CppObject>::operator>(const RefPtr<T_CppObject>& src) const
+bool RefPtr<T_CppObject>::operator>(const RefPtr& src) const
{
return (pCppObject_ > src.pCppObject_);
}
template <class T_CppObject> inline
-bool RefPtr<T_CppObject>::operator>=(const RefPtr<T_CppObject>& src) const
+bool RefPtr<T_CppObject>::operator>=(const RefPtr& src) const
{
return (pCppObject_ >= src.pCppObject_);
}
if(conn && conn->object_)
{
GObject* o = conn->object_;
- conn->object_ = 0;
+ conn->object_ = nullptr;
if(g_signal_handler_is_connected(o, conn->connection_id_)) //We check first, because during destruction, GTK+ sometimes seems to disconnect them for us, before we expect it to. See bug #87912
{
if(conn)
{
// the object has already lost track of this object.
- conn->object_ = 0;
+ conn->object_ = nullptr;
delete conn; // if there are connection objects referring to slot_ they are notified during destruction of slot_
}
template <class Bi, class Tr>
GSList* create_slist(Bi pbegin, Bi pend, Tr)
{
- GSList* head = 0;
+ GSList* head = nullptr;
while(pend != pbegin)
{
template <class For, class Tr>
GSList* create_slist(For pbegin, Tr)
{
- GSList* head = 0;
+ GSList* head = nullptr;
while(*pbegin)
{
if(ownership_ != Glib::OWNERSHIP_SHALLOW)
{
// Deep ownership: release each container element.
- for(GSList* node = pslist_; node != 0; 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
bool SListHandle<T,Tr>::empty() const
{
- return (pslist_ == 0);
+ return (pslist_ == nullptr);
}
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
IOStatus StreamIOChannel::read_vfunc(char* buf, gsize count, gsize& bytes_read)
{
- g_return_val_if_fail(stream_in_ != 0, IO_STATUS_ERROR);
+ g_return_val_if_fail(stream_in_ != nullptr, IO_STATUS_ERROR);
stream_in_->clear();
stream_in_->read(buf, count);
IOStatus StreamIOChannel::write_vfunc(const char* buf, gsize count, gsize& bytes_written)
{
- g_return_val_if_fail(stream_out_ != 0, IO_STATUS_ERROR);
+ g_return_val_if_fail(stream_out_ != nullptr, IO_STATUS_ERROR);
bytes_written = 0;
IOFlags StreamIOChannel::get_flags_vfunc()
{
gobj()->is_seekable = 1;
- gobj()->is_readable = (stream_in_ != 0);
- gobj()->is_writeable = (stream_out_ != 0);
+ gobj()->is_readable = (stream_in_ != nullptr);
+ gobj()->is_writeable = (stream_out_ != nullptr);
IOFlags flags = IO_FLAG_IS_SEEKABLE;
}
const char *const bufptr = str.c_str();
- char* endptr = 0;
+ char* endptr = nullptr;
const double result = g_ascii_strtod(bufptr + start_index, &endptr);
const int err_no = errno;
SlotList();
~SlotList();
+ // noncopyable
+ SlotList(const ThreadPool::SlotList&) = delete;
+ ThreadPool::SlotList& operator=(const ThreadPool::SlotList&) = delete;
+
sigc::slot<void>* push(const sigc::slot<void>& slot);
sigc::slot<void> pop(sigc::slot<void>* slot_ptr);
private:
Glib::Threads::Mutex mutex_;
std::list< sigc::slot<void> > list_;
-
- // noncopyable
- SlotList(const ThreadPool::SlotList&);
- ThreadPool::SlotList& operator=(const ThreadPool::SlotList&);
};
ThreadPool::SlotList::SlotList()
gobject_ (0),
slot_list_ (new SlotList())
{
- GError* error = 0;
+ GError* error = nullptr;
gobject_ = g_thread_pool_new(
&call_thread_entry_slot, slot_list_, max_threads, exclusive, &error);
if(error)
{
delete slot_list_;
- slot_list_ = 0;
+ slot_list_ = nullptr;
Glib::Error::throw_exception(error);
}
}
{
sigc::slot<void> *const slot_ptr = slot_list_->push(slot);
- GError* error = 0;
+ GError* error = nullptr;
g_thread_pool_push(gobject_, slot_ptr, &error);
if(error)
void ThreadPool::set_max_threads(int max_threads)
{
- GError* error = 0;
+ GError* error = nullptr;
g_thread_pool_set_max_threads(gobject_, max_threads, &error);
if(error)
bool ThreadPool::get_exclusive() const
{
- g_return_val_if_fail(gobject_ != 0, false);
+ g_return_val_if_fail(gobject_ != nullptr, false);
return gobject_->exclusive;
}
if(gobject_)
{
g_thread_pool_free(gobject_, immediately, 1);
- gobject_ = 0;
+ gobject_ = nullptr;
}
if(slot_list_)
{
slot_list_->lock_and_unlock();
delete slot_list_;
- slot_list_ = 0;
+ slot_list_ = nullptr;
}
}
Timer();
~Timer();
+ // not copyable
+ Timer(const Timer&) = delete;
+ Timer& operator=(const Timer&) = delete;
+
void start();
void stop();
void reset();
private:
GTimer* gobject_;
-
- // not copyable
- Timer(const Timer&);
- Timer& operator=(const Timer&);
};
ustring ustring::FormatStream::to_string() const
{
- GError* error = 0;
+ GError* error = nullptr;
#ifdef GLIBMM_HAVE_WIDE_STREAM
const std::wstring str = stream_.str();
std::string str;
is >> str;
- GError* error = 0;
+ GError* error = nullptr;
gsize n_bytes = 0;
const ScopedPtr<char> buf (g_locale_to_utf8(str.data(), str.size(), 0, &n_bytes, &error));
std::ostream& operator<<(std::ostream& os, const Glib::ustring& utf8_string)
{
- GError* error = 0;
+ GError* error = nullptr;
const ScopedPtr<char> buf (g_locale_from_utf8(utf8_string.raw().data(),
utf8_string.raw().size(), 0, 0, &error));
if (error)
std::wistream& operator>>(std::wistream& is, ustring& utf8_string)
{
- GError* error = 0;
+ GError* error = nullptr;
std::wstring wstr;
is >> wstr;
std::wostream& operator<<(std::wostream& os, const ustring& utf8_string)
{
- GError* error = 0;
+ GError* error = nullptr;
#if defined(__STDC_ISO_10646__) && SIZEOF_WCHAR_T == 4
// Avoid going through iconv if wchar_t always contains UCS-4.
class ustring::FormatStream
{
+public:
+
+ // noncopyable
+ FormatStream(const ustring::FormatStream&) = delete;
+ FormatStream& operator=(const ustring::FormatStream&) = delete;
+
private:
#ifdef GLIBMM_HAVE_WIDE_STREAM
typedef std::wostringstream StreamType;
#endif
StreamType stream_;
- // noncopyable
- FormatStream(const ustring::FormatStream&);
- FormatStream& operator=(const ustring::FormatStream&);
-
public:
FormatStream();
~FormatStream();
private:
ustring string_;
- // noncopyable
- Stringify(const ustring::Stringify<T>&);
- Stringify<T>& operator=(const ustring::Stringify<T>&);
-
public:
explicit inline Stringify(const T& arg) : string_ (ustring::format(arg)) {}
//TODO: Why is this here? See the template specialization:
explicit inline Stringify(const char* arg) : string_(arg) {}
+ // noncopyable
+ Stringify(const ustring::Stringify<T>&) = delete;
+ Stringify<T>& operator=(const ustring::Stringify<T>&) = delete;
+
inline const ustring* ptr() const { return &string_; }
};
private:
const ustring& string_;
- // noncopyable
- Stringify(const ustring::Stringify<ustring>&);
- Stringify<ustring>& operator=(const ustring::Stringify<ustring>&);
-
public:
explicit inline Stringify(const ustring& arg) : string_(arg) {}
+
+ // noncopyable
+ Stringify(const ustring::Stringify<ustring>&) = delete;
+ Stringify<ustring>& operator=(const ustring::Stringify<ustring>&) = delete;
+
inline const ustring* ptr() const { return &string_; }
};
private:
const ustring string_;
- // noncopyable
- Stringify(const ustring::Stringify<const char*>&);
- Stringify<ustring>& operator=(const ustring::Stringify<const char*>&);
-
public:
explicit inline Stringify(const char* arg) : string_(arg) {}
+
+ // noncopyable
+ Stringify(const ustring::Stringify<const char*>&) = delete;
+ Stringify<ustring>& operator=(const ustring::Stringify<const char*>&) = delete;
+
inline const ustring* ptr() const { return &string_; }
};
private:
const ustring string_;
- // noncopyable
- Stringify(const ustring::Stringify<char[N]>&);
- Stringify<ustring>& operator=(const ustring::Stringify<char[N]>&);
-
public:
explicit inline Stringify(const char arg[N]) : string_(arg) {}
+
+ // noncopyable
+ Stringify(const ustring::Stringify<char[N]>&) = delete;
+ Stringify<ustring>& operator=(const ustring::Stringify<char[N]>&) = delete;
+
inline const ustring* ptr() const { return &string_; }
};
private:
const ustring string_;
- // noncopyable
- Stringify(const ustring::Stringify<const char[N]>&);
- Stringify<ustring>& operator=(const ustring::Stringify<const char[N]>&);
-
public:
explicit inline Stringify(const char arg[N]) : string_(arg) {}
+
+ // noncopyable
+ Stringify(const ustring::Stringify<const char[N]>&) = delete;
+ Stringify<ustring>& operator=(const ustring::Stringify<const char[N]>&) = delete;
+
inline const ustring* ptr() const { return &string_; }
};
typedef std::vector<Glib::WrapNewFunction> WrapFuncTable;
-static WrapFuncTable* wrap_func_table = 0;
+static WrapFuncTable* wrap_func_table = nullptr;
} // anonymous namespace
if(wrap_func_table)
{
delete wrap_func_table;
- wrap_func_table = 0;
+ wrap_func_table = nullptr;
}
}
static Glib::ObjectBase* wrap_create_new_wrapper(GObject* object)
{
- g_return_val_if_fail(wrap_func_table != 0, 0);
+ g_return_val_if_fail(wrap_func_table != nullptr, 0);
const bool gtkmm_wrapper_already_deleted = (bool)g_object_get_qdata((GObject*)object, Glib::quark_cpp_wrapper_deleted_);
if(gtkmm_wrapper_already_deleted)
Glib::ObjectBase* wrap_create_new_wrapper_for_interface(GObject* object, GType interface_gtype)
{
- g_return_val_if_fail(wrap_func_table != 0, 0);
+ g_return_val_if_fail(wrap_func_table != nullptr, 0);
const bool gtkmm_wrapper_already_deleted = (bool)g_object_get_qdata((GObject*)object, Glib::quark_cpp_wrapper_deleted_);
if(gtkmm_wrapper_already_deleted)
//If no exact wrapper was created,
//create an instance of the interface,
//so we at least get the expected type:
- TInterface* result = 0;
+ TInterface* result = nullptr;
if(pCppObject)
{
result = dynamic_cast<TInterface*>(pCppObject);
const SlotTransform& transform_to,
const SlotTransform& transform_from)
{
- GBinding* binding = 0;
+ GBinding* binding = nullptr;
if (transform_to.empty() && transform_from.empty())
{
// No user-supplied transformations.
/** Decrement the reference count for this object.
* You should never need to do this manually - use the object via a RefPtr instead.
*/
- virtual void unreference() const;
+ void unreference() const override;
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
private:
Checksum::operator bool() const
{
- return gobject_ != 0;
+ return gobject_ != nullptr;
}
gssize Checksum::get_length(ChecksumType checksum_type)
{
if(gobject_ == reinterpret_cast<GIConv>(-1))
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
// Abuse g_convert() to create a GError object. This may seem a weird
// thing to do, but it gives us consistently translated error messages
g_convert("", 0, to_codeset.c_str(), from_codeset.c_str(), 0, 0, &gerror);
// If this should ever fail we're fucked.
- g_assert(gerror != 0);
+ g_assert(gerror != nullptr);
if(gerror) ::Glib::Error::throw_exception(gerror);
}
// NULL for anything but inbuf; work around that. (NULL outbuf
// or NULL *outbuf is allowed by Unix98.)
- char* outbuf = 0;
+ char* outbuf = nullptr;
gsize inbytes_left = 0;
gsize outbytes_left = 0;
std::string IConv::convert(const std::string& str)
{
gsize bytes_written = 0;
- GError* gerror = 0;
+ GError* gerror = nullptr;
char *const buf = g_convert_with_iconv(
str.data(), str.size(), gobject_, 0, &bytes_written, &gerror);
bool get_charset(std::string& charset)
{
- const char* charset_cstr = 0;
+ const char* charset_cstr = nullptr;
const bool is_utf8 = g_get_charset(&charset_cstr);
charset = charset_cstr;
const std::string& from_codeset)
{
gsize bytes_written = 0;
- GError* gerror = 0;
+ GError* gerror = nullptr;
char *const buf = g_convert(
str.data(), str.size(), to_codeset.c_str(), from_codeset.c_str(),
Glib::ustring locale_to_utf8(const std::string& opsys_string)
{
gsize bytes_written = 0;
- GError* gerror = 0;
+ GError* gerror = nullptr;
char *const buf = g_locale_to_utf8(
opsys_string.data(), opsys_string.size(), 0, &bytes_written, &gerror);
std::string locale_from_utf8(const Glib::ustring& utf8_string)
{
gsize bytes_written = 0;
- GError* gerror = 0;
+ GError* gerror = nullptr;
char *const buf = g_locale_from_utf8(
utf8_string.data(), utf8_string.bytes(), 0, &bytes_written, &gerror);
Glib::ustring filename_to_utf8(const std::string& opsys_string)
{
gsize bytes_written = 0;
- GError* gerror = 0;
+ GError* gerror = nullptr;
char *const buf = g_filename_to_utf8(
opsys_string.data(), opsys_string.size(), 0, &bytes_written, &gerror);
std::string filename_from_utf8(const Glib::ustring& utf8_string)
{
gsize bytes_written = 0;
- GError* gerror = 0;
+ GError* gerror = nullptr;
char *const buf = g_filename_from_utf8(
utf8_string.data(), utf8_string.bytes(), 0, &bytes_written, &gerror);
std::string filename_from_uri(const Glib::ustring& uri, Glib::ustring& hostname)
{
- char* hostname_buf = 0;
- GError* gerror = 0;
+ char* hostname_buf = nullptr;
+ GError* gerror = nullptr;
char *const buf = g_filename_from_uri(uri.c_str(), &hostname_buf, &gerror);
std::string filename_from_uri(const Glib::ustring& uri)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
char *const buf = g_filename_from_uri(uri.c_str(), 0, &gerror);
if(gerror) ::Glib::Error::throw_exception(gerror);
Glib::ustring filename_to_uri(const std::string& filename, const Glib::ustring& hostname)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
char *const buf = g_filename_to_uri(filename.c_str(), hostname.c_str(), &gerror);
if(gerror) ::Glib::Error::throw_exception(gerror);
Glib::ustring filename_to_uri(const std::string& filename)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
char *const buf = g_filename_to_uri(filename.c_str(), 0, &gerror);
if(gerror) ::Glib::Error::throw_exception(gerror);
Dir::Dir(const std::string& path)
{
- GError* error = 0;
+ GError* error = nullptr;
gobject_ = g_dir_open(path.c_str(), 0, &error);
if(error)
if(gobject_)
{
g_dir_close(gobject_);
- gobject_ = 0;
+ gobject_ = nullptr;
}
}
std::string basename_template (prefix);
basename_template += "XXXXXX"; // this sillyness shouldn't be in the interface
- GError* error = 0;
+ GError* error = nullptr;
ScopedPtr<char> buf_name_used;
const auto fileno = g_file_open_tmp(basename_template.c_str(), buf_name_used.addr(), &error);
int file_open_tmp(std::string& name_used)
{
- GError* error = 0;
+ GError* error = nullptr;
ScopedPtr<char> buf_name_used;
const auto fileno = g_file_open_tmp(0, buf_name_used.addr(), &error);
{
ScopedPtr<char> contents;
gsize length = 0;
- GError* error = 0;
+ GError* error = nullptr;
g_file_get_contents(filename.c_str(), contents.addr(), &length, &error);
const gchar *contents,
gssize length)
{
- GError* error = 0;
+ GError* error = nullptr;
g_file_set_contents(filename.c_str(), contents, length, &error);
ForeignIOChannel(GIOChannel* gobject, bool take_copy)
: Glib::IOChannel(gobject, take_copy), ref_count_(0) {}
- virtual void reference() const;
- virtual void unreference() const;
+ void reference() const override;
+ void unreference() const override;
private:
mutable int ref_count_;
gobject_ (gobject)
{
// This ctor should never be called for GlibmmIOChannel instances.
- g_assert(gobject != 0);
+ g_assert(gobject != nullptr);
g_assert(gobject->funcs != &GlibmmIOChannel::vfunc_table);
if(take_copy)
if(gobject_->funcs == &GlibmmIOChannel::vfunc_table)
{
// Disconnect the wrapper object so that it won't be deleted twice.
- reinterpret_cast<GlibmmIOChannel*>(gobject_)->wrapper = 0;
+ reinterpret_cast<GlibmmIOChannel*>(gobject_)->wrapper = nullptr;
}
const auto tmp_gobject = gobject_;
- gobject_ = 0;
+ gobject_ = nullptr;
g_io_channel_unref(tmp_gobject);
}
Glib::RefPtr<IOChannel> IOChannel::create_from_file(const std::string& filename, const std::string& mode)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
const auto channel = g_io_channel_new_file(filename.c_str(), mode.c_str(), &gerror);
if(gerror)
IOStatus IOChannel::read_line(Glib::ustring& line)
{
Glib::ScopedPtr<char> buf;
- GError* gerror = 0;
+ GError* gerror = nullptr;
gsize bytes = 0;
const auto status = g_io_channel_read_line(gobj(), buf.addr(), &bytes, 0, &gerror);
IOStatus IOChannel::read_to_end(Glib::ustring& str)
{
Glib::ScopedPtr<char> buf;
- GError* gerror = 0;
+ GError* gerror = nullptr;
gsize bytes = 0;
const auto status = g_io_channel_read_to_end(gobj(), buf.addr(), &bytes, &gerror);
IOStatus IOChannel::read(Glib::ustring& str, gsize count)
{
Glib::ScopedPtr<char> buf (g_new(char, count));
- GError* gerror = 0;
+ GError* gerror = nullptr;
gsize bytes = 0;
const auto status = g_io_channel_read_chars(gobj(), buf.get(), count, &bytes, &gerror);
IOStatus IOChannel::set_encoding(const std::string& encoding)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
const auto status = g_io_channel_set_encoding(
gobj(), (encoding.empty()) ? 0 : encoding.c_str(), &gerror);
Glib::RefPtr<IOChannel> wrap(GIOChannel* gobject, bool take_copy)
{
- IOChannel* cpp_object = 0;
+ IOChannel* cpp_object = nullptr;
if(gobject)
{
{
if(IOChannel *const wrapper = reinterpret_cast<GlibmmIOChannel*>(channel)->wrapper)
{
- wrapper->gobject_ = 0;
+ wrapper->gobject_ = nullptr;
delete wrapper;
}
* set_encoding("ISO-8859-15"). To set the channel to no encoding, use
* set_encoding() without any arguments.
*
- * You can create an IOChannel with one of the static create methods, or
- * implement one yourself, in which case you have to 1) override all
- * _vfunc() members. 2) set the GIOChannel flags in your constructor.
- *
- * @note This feature of being able to implement a custom Glib::IOChannel is
- * deprecated in glibmm 2.2. The vfunc interface has not yet stabilized
- * enough to allow that -- the C++ wrapper went in by pure accident. Besides,
- * it isn't terribly useful either. Thus please refrain from overriding any
- * IOChannel vfuncs.
+ * You can create an IOChannel with one of the static create methods.
*/
class IOChannel : public sigc::trackable
{
IOChannel(GIOChannel* gobject, bool take_copy);
#endif
+ //We don't put GLIBMM_DISABLE_DEPRECATED around these deprecated methods
+ //because they are virtual and that would make the ABI dependent on the ifdef.
+
+ /**
+ * @deprecated Custom Glib::IOChannel implementation was never really supported.
+ */
virtual IOStatus read_vfunc(char* buf, gsize count, gsize& bytes_read);
+
+ /**
+ * @deprecated Custom Glib::IOChannel implementation was never really supported.
+ */
virtual IOStatus write_vfunc(const char* buf, gsize count, gsize& bytes_written);
+
+ /**
+ * @deprecated Custom Glib::IOChannel implementation was never really supported.
+ */
virtual IOStatus seek_vfunc(gint64 offset, SeekType type);
+
+ /**
+ * @deprecated Custom Glib::IOChannel implementation was never really supported.
+ */
virtual IOStatus close_vfunc();
+
+ /**
+ * @deprecated Custom Glib::IOChannel implementation was never really supported.
+ */
virtual IOStatus set_flags_vfunc(IOFlags flags);
+
+ /**
+ * @deprecated Custom Glib::IOChannel implementation was never really supported.
+ */
virtual IOFlags get_flags_vfunc();
+
+ /**
+ * @deprecated Custom Glib::IOChannel implementation was never really supported.
+ */
virtual Glib::RefPtr<Glib::Source> create_watch_vfunc(IOCondition cond);
#ifndef DOXYGEN_SHOULD_SKIP_THIS
bool KeyFile::load_from_data(const Glib::ustring& data, KeyFileFlags flags)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
const gboolean result = g_key_file_load_from_data(
gobj(), data.c_str(), data.bytes(),
bool KeyFile::load_from_data_dirs(const std::string& file, std::string& full_path, KeyFileFlags flags)
{
- GError* gerror = 0;
- char* full_path_c = 0;
+ GError* gerror = nullptr;
+ char* full_path_c = nullptr;
const gboolean result = g_key_file_load_from_data_dirs(
gobj(), file.c_str(), &full_path_c,
bool KeyFile::load_from_dirs(const std::string& file, const Glib::ArrayHandle<std::string>& search_dirs, std::string& full_path, KeyFileFlags flags)
{
- GError* gerror = 0;
- char* full_path_c = 0;
+ GError* gerror = nullptr;
+ char* full_path_c = nullptr;
const gboolean result = g_key_file_load_from_dirs(
gobj(), file.c_str(), const_cast<const gchar**>(search_dirs.data()),
Glib::ustring KeyFile::to_data()
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
char *const str = g_key_file_to_data(gobj(), 0, &gerror);
if(gerror)
Glib::ArrayHandle<Glib::ustring> KeyFile::get_keys(const Glib::ustring& group_name) const
{
gsize length = 0;
- GError* gerror = 0;
+ GError* gerror = nullptr;
char** const array = g_key_file_get_keys(
const_cast<GKeyFile*>(gobj()),
Glib::ustring KeyFile::get_locale_string(const Glib::ustring& group_name,
const Glib::ustring& key) const
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
char *const str = g_key_file_get_locale_string(
const_cast<GKeyFile*>(gobj()),
(group_name.empty()) ? 0 : group_name.c_str(),
bool KeyFile::get_boolean(const Glib::ustring& key) const
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
const bool value =
static_cast<bool>(g_key_file_get_boolean(const_cast<GKeyFile*>(gobj()),
0, key.c_str(), &gerror));
int KeyFile::get_integer(const Glib::ustring& key) const
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
const int value = g_key_file_get_integer(const_cast<GKeyFile*>(gobj()),
0, key.c_str(), &gerror);
if(gerror)
gint64 KeyFile::get_int64(const Glib::ustring& key) const
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
const gint64 value = g_key_file_get_int64(const_cast<GKeyFile*>(gobj()), 0,
key.c_str(), &gerror);
guint64 KeyFile::get_uint64(const Glib::ustring& key) const
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
const guint64 value = g_key_file_get_uint64(const_cast<GKeyFile*>(gobj()),
0, key.c_str(), &gerror);
double KeyFile::get_double(const Glib::ustring& key) const
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
double retvalue = g_key_file_get_double(const_cast<GKeyFile*>(gobj()), 0, key.c_str(), &(gerror));
if(gerror)
GLIBMM_ERROR_ARG) const
{
gsize length = 0;
- GError* gerror = 0;
+ GError* gerror = nullptr;
char** const array = g_key_file_get_string_list(
const_cast<GKeyFile*>(gobj()),
GLIBMM_ERROR_ARG) const
{
gsize length = 0;
- GError* gerror = 0;
+ GError* gerror = nullptr;
char** const array = g_key_file_get_locale_string_list(
const_cast<GKeyFile*>(gobj()),
GLIBMM_ERROR_ARG) const
{
gsize length = 0;
- GError* gerror = 0;
+ GError* gerror = nullptr;
gboolean *const array = g_key_file_get_boolean_list(
const_cast<GKeyFile*>(gobj()),
GLIBMM_ERROR_ARG) const
{
gsize length = 0;
- GError* gerror = 0;
+ GError* gerror = nullptr;
int *const array = g_key_file_get_integer_list(
const_cast<GKeyFile*>(gobj()),
GLIBMM_ERROR_ARG) const
{
gsize length = 0;
- GError* gerror = 0;
+ GError* gerror = nullptr;
double *const array = g_key_file_get_double_list(const_cast<GKeyFile*>(gobj()),
group_name.c_str(), key.c_str(),
Glib::ustring KeyFile::get_comment() const
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
char *const str = g_key_file_get_comment(const_cast<GKeyFile*>(gobj()), 0, 0, &gerror);
GLIBMM_THROW(gerror);
Glib::ustring KeyFile::get_comment(const Glib::ustring& group_name GLIBMM_ERROR_ARG) const
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
char *const str = g_key_file_get_comment(const_cast<GKeyFile*>(gobj()),
(group_name.empty()) ? 0 : group_name.c_str(),
0, &gerror);
void KeyFile::set_comment(const Glib::ustring& comment GLIBMM_ERROR_ARG)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
g_key_file_set_comment(gobj(), 0, 0, comment.c_str(), &gerror);
GLIBMM_THROW(gerror);
void KeyFile::set_comment(const Glib::ustring& group_name, const Glib::ustring& comment
GLIBMM_ERROR_ARG)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
g_key_file_set_comment(gobj(), (group_name.empty()) ? 0 : group_name.c_str(),
0, comment.c_str(), &gerror);
GLIBMM_THROW(gerror);
for(; *pname && *pvalue; ++pname, ++pvalue)
attributes.insert(Parser::AttributeMap::value_type(*pname, *pvalue));
- g_return_if_fail(*pname == 0 && *pvalue == 0);
+ g_return_if_fail(*pname == nullptr && *pvalue == nullptr);
}
cpp_context.get_parser()->on_start_element(cpp_context, element_name, attributes);
ParseContext::~ParseContext()
{
- parser_ = 0;
+ parser_ = nullptr;
g_markup_parse_context_free(gobject_);
}
void ParseContext::parse(const Glib::ustring& text)
{
- GError* error = 0;
+ GError* error = nullptr;
g_markup_parse_context_parse(gobject_, text.data(), text.bytes(), &error);
if(error)
void ParseContext::parse(const char* text_begin, const char* text_end)
{
- GError* error = 0;
+ GError* error = nullptr;
g_markup_parse_context_parse(gobject_, text_begin, text_end - text_begin, &error);
if(error)
void ParseContext::end_parse()
{
- GError* error = 0;
+ GError* error = nullptr;
g_markup_parse_context_end_parse(gobject_, &error);
if(error)
ParseContext *const self = static_cast<ParseContext*>(data);
// Detect premature destruction.
- g_return_if_fail(self->parser_ == 0);
+ g_return_if_fail(self->parser_ == nullptr);
}
} // namespace Markup
std::string getenv(const std::string& variable, bool& found)
{
const char *const value = g_getenv(variable.c_str());
- found = (value != 0);
+ found = (value != nullptr);
return convert_const_gchar_ptr_to_stdstring(value);
}
if(!cresult)
return result;
- for(const gchar* const * iter = cresult; *iter != 0; ++iter)
+ for(const gchar* const * iter = cresult; *iter != nullptr; ++iter)
{
result.push_back(
convert_const_gchar_ptr_to_stdstring(*iter));
if(!cresult)
return result;
- for(const gchar* const * iter = cresult; *iter != 0; ++iter)
+ for(const gchar* const * iter = cresult; *iter != nullptr; ++iter)
{
result.push_back(
convert_const_gchar_ptr_to_stdstring(*iter));
Module::operator bool() const
{
- return (gobject_ != 0);
+ return (gobject_ != nullptr);
}
} // namespace Glib
* Glib::Module module("plugins/helloworld");
* if(module)
* {
- * void* func = 0;
+ * void* func = nullptr;
* bool found = get_symbol("some_function", func);
* }
* @endcode
{
sigc::slot<void, GNode*, const T&, GNode**> real_slot = sigc::ptr_fun(on_compare_child);
- GNode* child = 0;
+ GNode* child = nullptr;
typedef sigc::slot<void, GNode*> type_foreach_gnode_slot;
type_foreach_gnode_slot bound_slot = sigc::bind(real_slot, the_data, &child);
{
//We use a sigc::slot for the C callback, so we can bind some extra data.
sigc::slot<gboolean, GNode*, const T&, GNode**> real_slot = sigc::ptr_fun(on_compare_node);
- GNode* child = 0;
+ GNode* child = nullptr;
typedef sigc::slot<gboolean, GNode*> type_traverse_gnode_slot;
type_traverse_gnode_slot bound_slot = sigc::bind(real_slot, the_data, &child);
//Free the wrapped object (g_node_free not available)
g_slice_free(GNode, gobject_);
- gobject_ = 0;
+ gobject_ = nullptr;
}
///Create a new GNode, taking the contents of an existing node if one is specified.
- void clone(const NodeTree<T>* node = 0)
+ void clone(const NodeTree<T>* node = nullptr)
{
//Store the this pointer in the GNode so we can discover this wrapper later:
gobject_ = g_node_new(reinterpret_cast<gpointer>(this));
if(node)
{
//Prepend the copied children of @node to the constructing node.
- for(const NodeTree<T>* i = node->last_child(); i != 0; i = i->prev_sibling())
+ for(const NodeTree<T>* i = node->last_child(); i != nullptr; i = i->prev_sibling())
prepend(*(new NodeTree<T>(*i)));
}
}
if(has_ownership_)
g_option_context_free(gobj());
- gobject_ = 0;
+ gobject_ = nullptr;
}
void OptionContext::add_group(OptionGroup& group)
if(gobject_->long_name)
{
g_free((gchar*)(gobject_->long_name));
- gobject_->long_name = 0;
+ gobject_->long_name = nullptr;
}
//Note that we do not use NULL for an empty string,
if(gobject_->description)
{
g_free((gchar*)(gobject_->description));
- gobject_->description = 0;
+ gobject_->description = nullptr;
}
gobj()->description = (value).empty() ? 0 : g_strdup((value).c_str());
if(gobject_->arg_description)
{
g_free((gchar*)(gobject_->arg_description));
- gobject_->arg_description = 0;
+ gobject_->arg_description = nullptr;
}
gobj()->arg_description = (value).empty() ? 0 : g_strdup((value).c_str());
{ }
bool is_filename_option() const
- { return slot_filename_ != 0; }
+ { return slot_filename_ != nullptr; }
const OptionGroup::SlotOptionArgString* get_slot_string() const
{ return slot_string_; }
return false;
}
- const bool has_value = (value != 0);
+ const bool has_value = (value != nullptr);
const OptionArgCallback* const option_arg =
static_cast<const OptionArgCallback*>(cppOptionEntry.cpparg_);
try
if(has_ownership_)
{
g_option_group_unref(gobj());
- gobject_ = 0;
+ gobject_ = nullptr;
}
}
// Only one C variable shall be allocated for them.
// See https://bugzilla.gnome.org/show_bug.cgi?id=744854.
bool is_duplicate = false;
- void* carg = 0;
+ void* carg = nullptr;
if (arg_type != G_OPTION_ARG_CALLBACK)
{
for (type_map_entries::iterator iter = map_entries_.begin();
{
char** typed_arg = new char*;
//The C code will allocate a char* and put it here, for us to g_free() later.
- *typed_arg = 0;
+ *typed_arg = nullptr;
carg_ = typed_arg;
break;
case G_OPTION_ARG_NONE: // Actually a boolean.
{
gboolean* typed_arg = new gboolean;
- *typed_arg = 0;
+ *typed_arg = false;
carg_ = typed_arg;
break;
//or add_entry_filename().
auto option_arg = static_cast<OptionArgCallback*>(cpparg_);
delete option_arg;
- cpparg_ = 0;
+ cpparg_ = nullptr;
break;
}
}
}
- carg_ = 0;
+ carg_ = nullptr;
}
if(entry_)
RegexCompileFlags compile_options,
RegexMatchFlags match_options)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto regex = g_regex_new(pattern.c_str(), (GRegexCompileFlags)compile_options,
(GRegexMatchFlags)match_options, &gerror);
RegexMatchFlags match_options
)
{
- GMatchInfo* ginfo = 0;
+ GMatchInfo* ginfo = nullptr;
bool const result = static_cast<bool>(g_regex_match(gobj(), string.c_str(),
static_cast<GRegexMatchFlags>(match_options), &ginfo));
match_info.set_gobject(ginfo);
RegexMatchFlags match_options
)
{
- GError* gerror = 0;
- GMatchInfo* ginfo = 0;
+ GError* gerror = nullptr;
+ GMatchInfo* ginfo = nullptr;
bool const result = static_cast<bool>(g_regex_match_full(gobj(),
string.c_str(), -1, start_position,
RegexMatchFlags match_options
)
{
- GError* gerror = 0;
- GMatchInfo* ginfo = 0;
+ GError* gerror = nullptr;
+ GMatchInfo* ginfo = nullptr;
bool const result = static_cast<bool>(g_regex_match_full(gobj(),
string.c_str(), string_len, start_position,
bool Regex::match(const Glib::ustring& string, int start_position, RegexMatchFlags match_options)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
bool retvalue = g_regex_match_full(gobj(), string.c_str(), -1, start_position, ((GRegexMatchFlags)(match_options)), 0, &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
bool Regex::match(const Glib::ustring& string, gssize string_len, int start_position, RegexMatchFlags match_options)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
bool retvalue = g_regex_match_full(gobj(), string.c_str(), string_len, start_position, ((GRegexMatchFlags)(match_options)), 0, &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
RegexMatchFlags match_options
)
{
- GMatchInfo* ginfo = 0;
+ GMatchInfo* ginfo = nullptr;
bool const result = static_cast<bool>(g_regex_match_all(gobj(),
string.c_str(), static_cast<GRegexMatchFlags>(match_options),
&ginfo));
RegexMatchFlags match_options
)
{
- GError* gerror = 0;
- GMatchInfo* ginfo = 0;
+ GError* gerror = nullptr;
+ GMatchInfo* ginfo = nullptr;
bool const retvalue = static_cast<bool>(g_regex_match_all_full(gobj(),
string.c_str(), -1, start_position,
RegexMatchFlags match_options
)
{
- GError* gerror = 0;
- GMatchInfo* ginfo = 0;
+ GError* gerror = nullptr;
+ GMatchInfo* ginfo = nullptr;
bool const retvalue = static_cast<bool>(g_regex_match_all_full(gobj(),
string.c_str(), string_len, start_position,
bool Regex::match_all(const Glib::ustring& string, int start_position, RegexMatchFlags match_options)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
bool retvalue = g_regex_match_all_full(gobj(), string.c_str(), -1, start_position, ((GRegexMatchFlags)(match_options)), 0, &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
bool Regex::match_all(const Glib::ustring& string, gssize string_len, int start_position, RegexMatchFlags match_options)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
bool retvalue = g_regex_match_all_full(gobj(), string.c_str(), string_len, start_position, ((GRegexMatchFlags)(match_options)), 0, &(gerror));
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::ustring Regex::replace(const Glib::ustring& string, int start_position, const Glib::ustring& replacement, RegexMatchFlags match_options)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = Glib::convert_return_gchar_ptr_to_ustring(g_regex_replace(gobj(), string.c_str(), -1, start_position, replacement.c_str(), ((GRegexMatchFlags)(match_options)), &(gerror)));
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::ustring Regex::replace_literal(const Glib::ustring& string, int start_position, const Glib::ustring& replacement, RegexMatchFlags match_options)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = Glib::convert_return_gchar_ptr_to_ustring(g_regex_replace_literal(gobj(), string.c_str(), -1, start_position, replacement.c_str(), ((GRegexMatchFlags)(match_options)), &(gerror)));
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::StringArrayHandle Regex::split(const Glib::ustring& string, int start_position, RegexMatchFlags match_options, int max_tokens) const
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
auto retvalue = Glib::StringArrayHandle(g_regex_split_full(const_cast<GRegex*>(gobj()), string.c_str(), -1, start_position, ((GRegexMatchFlags)(match_options)), max_tokens, &(gerror)), Glib::OWNERSHIP_DEEP);
if(gerror)
::Glib::Error::throw_exception(gerror);
Glib::ArrayHandle<std::string> shell_parse_argv(const std::string& command_line)
{
- char** argv = 0;
+ char** argv = nullptr;
int argc = 0;
- GError* error = 0;
+ GError* error = nullptr;
g_shell_parse_argv(command_line.c_str(), &argc, &argv, &error);
std::string shell_unquote(const std::string& quoted_string)
{
- GError* error = 0;
+ GError* error = nullptr;
char *const buf = g_shell_unquote(quoted_string.c_str(), &error);
if(error)
{
const bool setup_slot = !child_setup.empty();
auto child_setup_ = child_setup;
- GError* gerror = 0;
+ GError* gerror = nullptr;
g_spawn_async_with_pipes(
(working_directory.empty()) ? 0 : working_directory.c_str(),
{
const bool setup_slot = !child_setup.empty();
auto child_setup_ = child_setup;
- GError* gerror = 0;
+ GError* gerror = nullptr;
g_spawn_async_with_pipes(
(working_directory.empty()) ? 0 : working_directory.c_str(),
{
const bool setup_slot = !child_setup.empty();
auto child_setup_ = child_setup;
- GError* gerror = 0;
+ GError* gerror = nullptr;
g_spawn_async(
(working_directory.empty()) ? 0 : working_directory.c_str(),
{
const bool setup_slot = !child_setup.empty();
auto child_setup_ = child_setup;
- GError* gerror = 0;
+ GError* gerror = nullptr;
g_spawn_async(
(working_directory.empty()) ? 0 : working_directory.c_str(),
Glib::ScopedPtr<char> buf_standard_output;
Glib::ScopedPtr<char> buf_standard_error;
- GError* gerror = 0;
+ GError* gerror = nullptr;
g_spawn_sync(
(working_directory.empty()) ? 0 : working_directory.c_str(),
Glib::ScopedPtr<char> buf_standard_output;
Glib::ScopedPtr<char> buf_standard_error;
- GError* gerror = 0;
+ GError* gerror = nullptr;
g_spawn_sync(
(working_directory.empty()) ? 0 : working_directory.c_str(),
void spawn_command_line_async(const std::string& command_line)
{
- GError* gerror = 0;
+ GError* gerror = nullptr;
g_spawn_command_line_async(command_line.c_str(), &gerror);
if(gerror)
{
Glib::ScopedPtr<char> buf_standard_output;
Glib::ScopedPtr<char> buf_standard_error;
- GError* gerror = 0;
+ GError* gerror = nullptr;
g_spawn_command_line_sync(
command_line.c_str(),
const Glib::ArrayHandle<std::string>& envp,
SpawnFlags flags = SPAWN_DEFAULT,
const SlotSpawnChildSetup& child_setup = SlotSpawnChildSetup(),
- Pid* child_pid = 0,
- int* standard_input = 0,
- int* standard_output = 0,
- int* standard_error = 0);
+ Pid* child_pid = nullptr,
+ int* standard_input = nullptr,
+ int* standard_output = nullptr,
+ int* standard_error = nullptr);
/** Like the main spawn_async_with_pipes() method, but inheriting the parent's environment.
*
const Glib::ArrayHandle<std::string>& argv,
SpawnFlags flags = SPAWN_DEFAULT,
const SlotSpawnChildSetup& child_setup = SlotSpawnChildSetup(),
- Pid* child_pid = 0,
- int* standard_input = 0,
- int* standard_output = 0,
- int* standard_error = 0);
+ Pid* child_pid = nullptr,
+ int* standard_input = nullptr,
+ int* standard_output = nullptr,
+ int* standard_error = nullptr);
/** See spawn_async_with_pipes() for a full description. This function
* simply calls the spawn_async_with_pipes() without any pipes.
const Glib::ArrayHandle<std::string>& envp,
SpawnFlags flags = SPAWN_DEFAULT,
const SlotSpawnChildSetup& child_setup = SlotSpawnChildSetup(),
- Pid* child_pid = 0);
+ Pid* child_pid = nullptr);
/** Like the main spawn_async() method, but inheriting the parent's environment.
*
const Glib::ArrayHandle<std::string>& argv,
SpawnFlags flags = SPAWN_DEFAULT,
const SlotSpawnChildSetup& child_setup = SlotSpawnChildSetup(),
- Pid* child_pid = 0);
+ Pid* child_pid = nullptr);
/** Executes a child synchronously (waits for the child to exit before returning).
* All output from the child is stored in @a standard_output and @a standard_error,
const Glib::ArrayHandle<std::string>& envp,
SpawnFlags flags = SPAWN_DEFAULT,
const SlotSpawnChildSetup& child_setup = SlotSpawnChildSetup(),
- std::string* standard_output = 0,
- std::string* standard_error = 0,
- int* exit_status = 0);
+ std::string* standard_output = nullptr,
+ std::string* standard_error = nullptr,
+ int* exit_status = nullptr);
/** Like the main spawn_sync() method, but inheriting the parent's environment.
*
const Glib::ArrayHandle<std::string>& argv,
SpawnFlags flags = SPAWN_DEFAULT,
const SlotSpawnChildSetup& child_setup = SlotSpawnChildSetup(),
- std::string* standard_output = 0,
- std::string* standard_error = 0,
- int* exit_status = 0);
+ std::string* standard_output = nullptr,
+ std::string* standard_error = nullptr,
+ int* exit_status = nullptr);
/** A simple version of spawn_async() that parses a command line with
* shell_parse_argv() and passes it to spawn_async(). It runs a
* @throws ShellError If the command line could not be parsed.
*/
void spawn_command_line_sync(const std::string& command_line,
- std::string* standard_output = 0,
- std::string* standard_error = 0,
- int* exit_status = 0);
+ std::string* standard_output = nullptr,
+ std::string* standard_error = nullptr,
+ int* exit_status = nullptr);
/** On some platforms, notably WIN32, the Pid type represents a resource
* which must be closed to prevent resource leaking. close_pid()
// Make a copy of slot on the heap
const auto slot_copy = new sigc::slot<void>(slot);
- GError* error = 0;
+ GError* error = nullptr;
const auto thread = g_thread_try_new(NULL,
&call_thread_entry_slot, slot_copy, &error);
// Make a copy of slot on the heap
const auto slot_copy = new sigc::slot<void>(slot);
- GError* error = 0;
+ GError* error = nullptr;
const auto thread = g_thread_create_full(
&call_thread_entry_slot, slot_copy, stack_size, joinable,
/** Initializes the GLib thread system.
* @deprecated Calling thread_init() is no longer necessary and no longer has any effect.
*/
-void thread_init(GThreadFunctions* vtable = 0);
+void thread_init(GThreadFunctions* vtable = nullptr);
/** Returns whether the thread system is initialized.
* @return @c true, if the thread system is initialized.
* @code
* Glib::Cond data_cond;
* Glib::Mutex data_mutex;
- * void* current_data = 0;
+ * void* current_data = nullptr;
*
* void push_data(void* data)
* {
* data_cond.wait(data_mutex);
*
* void *const data = current_data;
- * current_data = 0;
+ * current_data = nullptr;
*
* return data;
* }
// Make a copy of slot on the heap.
const auto slot_copy = new sigc::slot<void>(slot);
- GError* error = 0;
+ GError* error = nullptr;
auto thread = g_thread_try_new(name.empty() ? 0 : name.c_str(),
&call_thread_entry_slot, slot_copy, &error);
* @code
* Glib::Threads::Cond data_cond;
* Glib::Threads::Mutex data_mutex;
- * void* current_data = 0;
+ * void* current_data = nullptr;
*
* void push_data(void* data)
* {
* data_cond.wait(data_mutex);
*
* void* const data = current_data;
- * current_data = 0;
+ * current_data = nullptr;
*
* return data;
* }
* return 0; // timeout
*
* void* const data = current_data;
- * current_data = 0;
+ * current_data = nullptr;
*
* return data;
* }
void VariantStringBase::create_object_path(VariantStringBase& output,
const std::string& object_path)
{
- GVariant* result = 0;
+ GVariant* result = nullptr;
result = g_variant_new_object_path(object_path.c_str());
g_variant_ref_sink(result);
output.init(result);
void VariantStringBase::create_signature(VariantStringBase& output,
const std::string& signature)
{
- GVariant* result = 0;
+ GVariant* result = nullptr;
result = g_variant_new_signature(signature.c_str());
g_variant_ref_sink(result);
output.init(result);
// use the actual type (which may differ from container_variant_type, if
// the GVariant contains strings, object paths or DBus type signatures),
// otherwise let g_variant_get() report what's wrong with the type.
- GVariantIter* g_iter = 0;
+ GVariantIter* g_iter = nullptr;
g_variant_get(const_cast<GVariant*>(gobj()),
is_castable_to(container_variant_type) ?
get_type_string().c_str() : container_variant_type.get_string().c_str(),
{
const VariantType vtype = get_type();
- const char* pch = 0;
+ const char* pch = nullptr;
if(vtype.equal(VARIANT_TYPE_BYTESTRING))
pch = g_variant_get_bytestring(gobject_);
else //g_variant_get_string() can handle strings, object paths, and signatures.
if(castitem)
gobject_ = g_variant_type_copy(castitem);
else
- gobject_ = 0;
+ gobject_ = nullptr;
}
VariantType::VariantType(const std::string& type_string)
if(castitem)
gobject_ = g_variant_type_copy(castitem);
else
- gobject_ = 0;
+ gobject_ = nullptr;
return *this;
}
<< action.property.get_value() << "'." << std::endl;
success &= action.property.get_value() == "A new value.";
- gchar* prop_value = 0;
+ gchar* prop_value = nullptr;
g_object_set(action.gobj(), "custom_property", "Another value", NULL);
g_object_get(action.gobj(), "custom_property", &prop_value, NULL);
std::cout << "The custom property after g_object_set/get() is '"
<< prop_value << "'." << std::endl;
success &= std::strcmp(prop_value, "Another value") == 0;
g_free(prop_value);
- prop_value = 0;
+ prop_value = nullptr;
std::cout << "The custom property through the Glib::Property<> is '"
<< action.property.get_value() << "'." << std::endl;
GList*
create_list()
{
- GList* head = 0;
+ GList* head = nullptr;
for(unsigned int iter(0); iter < magic_limit; ++iter)
{
{
dup[iter] = array[iter];
}
- dup[magic_limit] = 0;
+ dup[magic_limit] = nullptr;
return dup;
}
std::string strObjectName = g_type_name(gtype);
//Get the list of properties:
- GParamSpec** ppParamSpec = 0;
+ GParamSpec** ppParamSpec = nullptr;
guint iCount = 0;
if(G_TYPE_IS_OBJECT(gtype))
{
std::string strResult;
std::string strObjectName = g_type_name(gtype);
- gpointer gclass_ref = 0;
- gpointer ginterface_ref = 0;
+ gpointer gclass_ref = nullptr;
+ gpointer ginterface_ref = nullptr;
if(G_TYPE_IS_OBJECT(gtype))
gclass_ref = g_type_class_ref(gtype); //Ensures that class_init() is called.
gchar* pchNum = g_strdup_printf("%d", j);
std::string strParamName = "p" + std::string(pchNum);
g_free(pchNum);
- pchNum = 0;
+ pchNum = nullptr;
//Just like above, for the return type:
std::string strTypeName = get_type_name_signal( typeParamMangled & ~G_SIGNAL_TYPE_STATIC_SCOPE, is_a_pointer_func ); //The type is mangled with a flag. Hacky.
:
gobject_(other.gobject_)
{
- other.gobject_ = 0;
+ other.gobject_ = nullptr;
}
__CPPNAME__& __CPPNAME__::operator=(__CPPNAME__`'&& other)
friend class __CPPNAME__`'_Class;
static CppClassType `'__BASE__`'_class_;
-private:
// noncopyable
- __CPPNAME__`'(const __CPPNAME__&);
- __CPPNAME__& operator=(const __CPPNAME__&);
+ __CPPNAME__`'(const __CPPNAME__&) = delete;
+ __CPPNAME__& operator=(const __CPPNAME__&) = delete;
protected:
explicit __CPPNAME__`'(const Glib::ConstructParams& construct_params);
//This is just to avoid an "unused variable" warning when there are no vfuncs or signal handlers to connect.
//This is a temporary fix until I find out why I can not seem to derive a GtkFileChooser interface. murrayc
- g_assert(klass != 0);
+ g_assert(klass != nullptr);
_IMPORT(SECTION_PCC_CLASS_INIT_VFUNCS)
typedef __CNAME__ BaseObjectType;
typedef __CCLASS__ BaseClassType;
+ // noncopyable
+ __CPPNAME__`'(const __CPPNAME__&) = delete;
+ __CPPNAME__& operator=(const __CPPNAME__&) = delete;
+
private:
friend class __CPPNAME__`'_Class;
static CppClassType `'__BASE__`'_class_;
- // noncopyable
- __CPPNAME__`'(const __CPPNAME__&);
- __CPPNAME__& operator=(const __CPPNAME__&);
-
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
protected:
/**
if(castitem)
gobject_ = __OPAQUE_FUNC_COPY`'(castitem);
else
- gobject_ = 0;
+ gobject_ = nullptr;
}
}
')
__CPPNAME__`'();
void operator delete(void*, std::size_t);
-private:
// noncopyable
- __CPPNAME__`'(const __CPPNAME__&);
- __CPPNAME__& operator=(const __CPPNAME__&);
+ __CPPNAME__`'(const __CPPNAME__&) = delete;
+ __CPPNAME__& operator=(const __CPPNAME__&) = delete;
+private:
_IMPORT(SECTION_CLASS2)
')
')dnl
')',dnl End if a C++ output parameter is specified.
dnl If is errthrow or refreturn
-`ifelse(`$11',,,` GError* gerror = 0;
+`ifelse(`$11',,,` GError* gerror = nullptr;
')dnl
dnl If a slot type has been specified insert a slot copy declaration.
ifelse(`$18',,,dnl
ifelse(`$3',void,,`ifelse(`$6',,,` return retval;
')')dnl
',dnl End if a C++ output parameter is specified.
-`ifelse(`$10',,,` GError* gerror = 0;')
+`ifelse(`$10',,,` GError* gerror = nullptr;')
dnl If a slot type has been specified insert a slot copy declaration.
ifelse(`$15',,,dnl
dnl See if the slot should or should not be copied
',`dnl
_PARENT_GCLASS_FROM_OBJECT($8)dnl
') );
-dnl g_assert(base != 0);
+dnl g_assert(base != nullptr);
// Call the original underlying C function:
if(base && base->$2)
',`dnl
_PARENT_GCLASS_FROM_OBJECT(gobject_)dnl
') );
-dnl g_assert(base != 0);
+dnl g_assert(base != nullptr);
if(base && base->$2)
ifelse($3,void,`dnl
',`dnl
_PARENT_GCLASS_FROM_OBJECT($8)dnl
') );
-dnl g_assert(base != 0);
+dnl g_assert(base != nullptr);
// Call the original underlying C function:
if(base && base->$2)
',`dnl
_PARENT_GCLASS_FROM_OBJECT(gobject_)dnl
') );
-dnl g_assert(base != 0);
+dnl g_assert(base != nullptr);
if(base && base->$2)
{
ifelse($10,errthrow,`dnl
- GError* gerror = 0;
+ GError* gerror = nullptr;
')dnl
ifelse($3,void,`dnl
(*base->$2)`'(ifelse(`$7',1,const_cast<__CNAME__*>(gobj()),gobj())`'_COMMA_PREFIX($6));
projects / platform / upstream / glibmm.git / commitdiff