external/srs
1
0
Fork 0
mirror of https://github.com/ossrs/srs.git synced 2025-03-09 15:49:59 +00:00
Code Issues Releases Wiki Activity

UniquePtr: Support SrsUniquePtr to replace SrsAutoFree. v6.0.136 (#4109)

Browse source 
To manage an object:

```cpp
// Before
MyClass* ptr = new MyClass();
SrsAutoFree(MyClass, ptr);
ptr->do_something();

// Now
SrsUniquePtr<MyClass> ptr(new MyClass());
ptr->do_something();
```

To manage an array of objects:

```cpp
// Before
char* ptr = new char[10];
SrsAutoFreeA(char, ptr);
ptr[0] = 0xf;

// Now
SrsUniquePtr<char[]> ptr(new char[10]);
ptr[0] = 0xf;
```

In fact, SrsUniquePtr is a limited subset of SrsAutoFree, mainly
managing pointers and arrays. SrsUniquePtr is better than SrsAutoFree
because it has the same API to standard unique ptr.

```cpp
SrsUniquePtr<MyClass> ptr(new MyClass());
ptr->do_something();
MyClass* p = ptr.get();
```

SrsAutoFree actually uses a pointer to a pointer, so it can be set to
NULL, allowing the pointer's value to be changed later (this usage is
different from SrsUniquePtr).

```cpp
// OK to free ptr correctly.
MyClass* ptr;
SrsAutoFree(MyClass, ptr);
ptr = new MyClass();

// Crash because ptr is an invalid pointer.
MyClass* ptr;
SrsUniquePtr<MyClass> ptr(ptr);
ptr = new MyClass();
```

Additionally, SrsAutoFreeH can use specific release functions, which
SrsUniquePtr does not support.

---------

Co-authored-by: Jacob Su <suzp1984@gmail.com>
This commit is contained in:
Winlin 2024-07-09 10:29:36 +08:00 • committed by GitHub
parent baf22d01c1
commit 23d2602c34
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
72 changed files with 1720 additions and 1669 deletions
Download patch file Download diff file Expand all files Collapse all files

28
trunk/src/app/srs_app_config.cpp
View file

@ -1157,13 +1157,13 @@ srs_error_t SrsConfDirective::parse_conf(SrsConfigBuffer* buffer, SrsDirectiveCo
srs_assert(!file.empty());
srs_trace("config parse include %s", file.c_str());
SrsConfigBuffer* include_file_buffer = NULL;
SrsAutoFree(SrsConfigBuffer, include_file_buffer);
if ((err = conf->build_buffer(file, &include_file_buffer)) != srs_success) {
SrsConfigBuffer* include_file_buffer_raw = NULL;
if ((err = conf->build_buffer(file, &include_file_buffer_raw)) != srs_success) {
return srs_error_wrap(err, "buffer fullfill %s", file.c_str());
}
SrsUniquePtr<SrsConfigBuffer> include_file_buffer(include_file_buffer_raw);
if ((err = parse_conf(include_file_buffer, SrsDirectiveContextFile, conf)) != srs_success) {
if ((err = parse_conf(include_file_buffer.get(), SrsDirectiveContextFile, conf)) != srs_success) {
return srs_error_wrap(err, "parse include buffer %s", file.c_str());
}
}
@ -1628,10 +1628,8 @@ srs_error_t SrsConfig::reload_vhost(SrsConfDirective* old_root)
srs_error_t SrsConfig::reload_conf(SrsConfig* conf)
{
srs_error_t err = srs_success;
SrsConfDirective* old_root = root;
SrsAutoFree(SrsConfDirective, old_root);
SrsUniquePtr<SrsConfDirective> old_root(root);
root = conf->root;
conf->root = NULL;
@ -1665,14 +1663,14 @@ srs_error_t SrsConfig::reload_conf(SrsConfig* conf)
}
// Merge config: rtc_server
if ((err = reload_rtc_server(old_root)) != srs_success) {
if ((err = reload_rtc_server(old_root.get())) != srs_success) {
return srs_error_wrap(err, "http steram");;
}
// TODO: FIXME: support reload stream_caster.
// merge config: vhost
if ((err = reload_vhost(old_root)) != srs_success) {
if ((err = reload_vhost(old_root.get())) != srs_success) {
return srs_error_wrap(err, "vhost");;
}
@ -2260,13 +2258,13 @@ srs_error_t SrsConfig::parse_file(const char* filename)
return srs_error_new(ERROR_SYSTEM_CONFIG_INVALID, "empty config");
}
SrsConfigBuffer* buffer = NULL;
SrsAutoFree(SrsConfigBuffer, buffer);
if ((err = build_buffer(config_file, &buffer)) != srs_success) {
SrsConfigBuffer* buffer_raw = NULL;
if ((err = build_buffer(config_file, &buffer_raw)) != srs_success) {
return srs_error_wrap(err, "buffer fullfill %s", filename);
}
if ((err = parse_buffer(buffer)) != srs_success) {
SrsUniquePtr<SrsConfigBuffer> buffer(buffer_raw);
if ((err = parse_buffer(buffer.get())) != srs_success) {
return srs_error_wrap(err, "parse buffer %s", filename);
}