Realtime timers and timer queues. │ │ │ │ +
Runtime functions. │ │ │ │ More...
│ │ │ │ -#include <ucommon/linked.h>#include <ucommon/platform.h>#include <unistd.h>#include <sys/time.h>#include <time.h>Go to the source code of this file.
│ │ │ ││ │ │ │ -Namespaces | |
| namespace | ucommon |
| Common namespace for all ucommon objects. | |
│ │ │ │ -Typedefs | |
| typedef Timer | ucommon::timer_t |
| A convenience type for timers. | |
│ │ │ │ Functions | |
| class | ucommon::__attribute__ ((visibility("default"))) ExclusiveProtocol |
| An exclusive locking protocol interface base. | |
| __attribute__ ((visibility("default"))) void cpr_runtime_error(const char *text) = NULL) | |
| Function to handle runtime errors. | |
| template<typename T > | |
| void | freep (T **handle) |
| template<typename T > | |
| T * | newp (T **handle) |
│ │ │ │ Variables | |
| class __attribute__((visibility("default"))) TimerQueue typedef TimerQueue::event | ucommon::TQEvent |
| A timer queue for timer events. | |
| caddr_t | address |
| caddr_t size_t | known |
| void * | mem2 |
| const char * | s2 |
| size_t | size |
| uint16_t | v |
Realtime timers and timer queues.
│ │ │ │ -This offers ucommon support for realtime high-resolution threadsafe timers and timer queues. Threads may be scheduled by timers and timer queues may be used to inject timer events into callback objects or through virtuals.
│ │ │ │ +Runtime functions.
│ │ │ │ +This includes common runtime library functions we may need portably.
│ │ │ │ + │ │ │ │ + │ │ │ │ +Definition in file cpr.h.
│ │ │ │ +| __attribute__ | │ │ │ │ +( | │ │ │ │ +(visibility("default")) | │ │ │ │ +) | │ │ │ │ +const = NULL) | │ │ │ │ +
Function to handle runtime errors.
│ │ │ │ +Portable swap code.
│ │ │ │ +Portable memory placement helper function.
│ │ │ │ +Portable memory allocation helper function.
│ │ │ │ +When using the standard C library, runtime errors are handled by a simple abort. When using the stdc++ library with stdexcept, then std::runtime_error will be thrown.
| text | of runtime error. |
Handles out of heap error as a runtime error.
| size | of memory block to allocate from heap. |
This is used to process "placement" new operators where a new object is constructed over a pre-allocated area of memory. This handles invalid values through runtime error.
| size | of object being constructed. |
| address | where the object is being placed. |
| known | size of the location we are constructing the object in. |
| mem1 | to swap. |
| mem2 | to swap. |
| size | of swap area. |
| void freep | │ │ │ │ +( | │ │ │ │ +T ** | │ │ │ │ +handle | ) | │ │ │ │ +│ │ │ │ + |
| T * newp | │ │ │ │ +( | │ │ │ │ +T ** | │ │ │ │ +handle | ) | │ │ │ │ +│ │ │ │ + |
| caddr_t address | │ │ │ │ +
| caddr_t size_t known | │ │ │ │ +
Definition in file timers.h.
│ │ │ │ -| void* mem2 | │ │ │ │ +
| const char * s2 | │ │ │ │ +
| const char size_t size | │ │ │ │ +
| uint32_t v | │ │ │ │ +
1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,46 +3,105 @@
│ │ │ │ │ * _N_a_m_e_s_p_a_c_e_s
│ │ │ │ │ * _D_a_t_a_ _S_t_r_u_c_t_u_r_e_s
│ │ │ │ │ * _F_i_l_e_s
│ │ │ │ │ * _E_x_a_m_p_l_e_s
│ │ │ │ │ * _F_i_l_e_ _L_i_s_t
│ │ │ │ │ * _G_l_o_b_a_l_s
│ │ │ │ │ * _u_c_o_m_m_o_n
│ │ │ │ │ -_N_a_m_e_s_p_a_c_e_s | _T_y_p_e_d_e_f_s | _F_u_n_c_t_i_o_n_s | _V_a_r_i_a_b_l_e_s
│ │ │ │ │ -timers.h File Reference
│ │ │ │ │ -Realtime timers and timer queues. _M_o_r_e_._._.
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_l_i_n_k_e_d_._h>
│ │ │ │ │ +_F_u_n_c_t_i_o_n_s | _V_a_r_i_a_b_l_e_s
│ │ │ │ │ +cpr.h File Reference
│ │ │ │ │ +Runtime functions. _M_o_r_e_._._.
│ │ │ │ │ +#include <_u_c_o_m_m_o_n_/_p_l_a_t_f_o_r_m_._h>
│ │ │ │ │ #include 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,15 +3,15 @@
│ │ │ │ │ * _N_a_m_e_s_p_a_c_e_s
│ │ │ │ │ * _D_a_t_a_ _S_t_r_u_c_t_u_r_e_s
│ │ │ │ │ * _F_i_l_e_s
│ │ │ │ │ * _E_x_a_m_p_l_e_s
│ │ │ │ │ * _F_i_l_e_ _L_i_s_t
│ │ │ │ │ * _G_l_o_b_a_l_s
│ │ │ │ │ * _u_c_o_m_m_o_n
│ │ │ │ │ -timers.h
│ │ │ │ │ +cpr.h
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _d_o_c_u_m_e_n_t_a_t_i_o_n_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ 1// Copyright (C) 2006-2014 David Sugar, Tycho Softworks.
│ │ │ │ │ 2// Copyright (C) 2015-2020 Cherokees of Idaho.
│ │ │ │ │ 3//
│ │ │ │ │ 4// This file is part of GNU uCommon C++.
│ │ │ │ │ 5//
│ │ │ │ │ 6// GNU uCommon C++ is free software: you can redistribute it and/or modify
│ │ │ │ │ @@ -23,200 +23,110 @@
│ │ │ │ │ 12// but WITHOUT ANY WARRANTY; without even the implied warranty of
│ │ │ │ │ 13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
│ │ │ │ │ 14// GNU Lesser General Public License for more details.
│ │ │ │ │ 15//
│ │ │ │ │ 16// You should have received a copy of the GNU Lesser General Public License
│ │ │ │ │ 17// along with GNU uCommon C++. If not, see .
.Generic templates for C++. │ │ │ │ +
This library holds basic cryptographic functions and secure socket support for use with GNU uCommon C++. │ │ │ │ More...
│ │ │ │ -#include <ucommon/cpr.h>#include <cstdlib>#include <cstring>#include <stdexcept>Go to the source code of this file.
│ │ │ ││ │ │ │ -Data Structures | |
| class | ucommon::array_pointer< T > |
| Generic smart array class. More... | |
| class | ucommon::pointer< T > |
| Generic smart pointer class. More... | |
| class | ucommon::save_restore< T > |
| Save and restore global objects in function call stack frames. More... | |
│ │ │ │ Namespaces | |
| namespace | ucommon |
| Common namespace for all ucommon objects. | |
│ │ │ │ Macros | |
| #define | THROW(x) throw x |
| #define | THROWS(x) throw(x) |
| #define | THROWS_ANY throw() |
| #define | MAX_CIPHER_KEYSIZE 512 |
| #define | MAX_DIGEST_HASHSIZE 512 |
│ │ │ │ +Typedefs | |
| typedef Cipher | ucommon::cipher_t |
| Convenience type for generic ciphers. | |
| typedef Digest | ucommon::digest_t |
| Convenience type for generic digests. | |
| typedef HMAC | ucommon::hmac_t |
| Convenience type for generic digests. | |
| typedef secure::string | ucommon::keystring_t |
| typedef Cipher::Key | ucommon::skey_t |
| Convenience type for generic cipher key. | |
│ │ │ │ Functions | |
| template<typename T > | |
| bool | ucommon::bound (const T *pointer, const T *base, size_t count) |
| Convenience function to check memory arrays. | |
| template<typename T > | |
| T & | ucommon::clear (T &o) |
| template<typename T > | |
| T | ucommon::copy (const T &src) |
| Convenience function to copy objects. | |
| template<typename T > | |
| T & | ucommon::copy (const T &src, T &to) |
| template<typename T > | |
| void | ucommon::copy_unsafe (T *target, const T *source) |
| Convenience function to copy class. | |
| template<typename T > | |
| T & | ucommon::deref_pointer (T *pointer) |
| Convert a pointer to a reference with type checking. | |
| template<typename T > | |
| T * | ucommon::dup (const T &object) |
| Convenience function to duplicate object pointer to heap. | |
| template<> | |
| char * | ucommon::dup< char > (const char &object) |
| template<typename T > | |
| void | ucommon::dupfree (T object) |
| template<> | |
| void | ucommon::dupfree< char * > (char *object) |
| template<typename T > | |
| bool | ucommon::is (T &object) |
| Convenience function to validate object assuming it is castable to bool. | |
| template<typename T > | |
| bool | ucommon::isnull (T &object) |
| Convenience function to test pointer object. | |
| template<typename T > | |
| bool | ucommon::isnullp (T *object) |
| Convenience function to test pointer-pointer object. | |
| template<typename T > | |
| T &() | ucommon::limit (T &value, T &low, T &high) |
| Convenience macro to range restrict values. | |
| template<typename T > | |
| T &() | ucommon::max (T &o1, T &o2) |
| Convenience function to return max of two objects. | |
| template<typename T > | |
| T &() | ucommon::min (T &o1, T &o2) |
| Convenience function to return min of two objects. | |
| template<typename T > | |
| T & | ucommon::move (T &src, T &to) |
| Convenience function to move objects. | |
| template<typename T > | |
| void | ucommon::reset_unsafe (T &object) |
| Convenience function to reset an existing object. | |
| template<typename T > | |
| void | ucommon::store_unsafe (T &target, const T *source) |
| Convenience function to store object pointer into object. | |
| template<typename T > | |
| void | ucommon::swap (T &o1, T &o2) |
| Convenience function to swap objects. | |
| template<typename T > | |
| void | ucommon::zero_unsafe (T &object) |
| Convenience function to zero an object and restore type info. | |
| class | ucommon::__attribute__ ((visibility("default"))) ExclusiveProtocol |
| An exclusive locking protocol interface base. | |
| template<typename T > | |
| class __attribute__((visibility("default"))) sstream void | ucommon::clearmem (T &var) |
| Secure socket using std::iostream. | |
| void | ucommon::zerofill (void *addr, size_t size) |
Generic templates for C++.
│ │ │ │ -These are templates that do not depend on any ucommon classes. They can be used for generic C++ programming.
│ │ │ │ +This library holds basic cryptographic functions and secure socket support for use with GNU uCommon C++.
│ │ │ │ +This library might be used in conjunction with openssl, gnutls, etc. If no secure socket library is available, then a stub library may be used with very basic cryptographic support.
│ │ │ │ │ │ │ │ -Definition in file generics.h.
│ │ │ │ +Definition in file secure.h.
│ │ │ │| #define THROW | │ │ │ │ -( | │ │ │ │ -│ │ │ │ - | x | ) | │ │ │ │ -throw x | │ │ │ │ -
Definition at line 37 of file generics.h.
│ │ │ │ - │ │ │ │ -| #define THROWS | │ │ │ │ -( | │ │ │ │ -│ │ │ │ - | x | ) | │ │ │ │ -throw(x) | │ │ │ │ +#define MAX_CIPHER_KEYSIZE 512 | │ │ │ │
Definition at line 42 of file generics.h.
│ │ │ │ + │ │ │ │ │ │ │ │| #define THROWS_ANY throw() | │ │ │ │ +#define MAX_DIGEST_HASHSIZE 512 | │ │ │ │
Definition at line 43 of file generics.h.
│ │ │ │ + │ │ │ │ │ │ │ │ 1.9.8
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,140 +3,70 @@
│ │ │ │ │ * _N_a_m_e_s_p_a_c_e_s
│ │ │ │ │ * _D_a_t_a_ _S_t_r_u_c_t_u_r_e_s
│ │ │ │ │ * _F_i_l_e_s
│ │ │ │ │ * _E_x_a_m_p_l_e_s
│ │ │ │ │ * _F_i_l_e_ _L_i_s_t
│ │ │ │ │ * _G_l_o_b_a_l_s
│ │ │ │ │ * _u_c_o_m_m_o_n
│ │ │ │ │ -_D_a_t_a_ _S_t_r_u_c_t_u_r_e_s | _N_a_m_e_s_p_a_c_e_s | _M_a_c_r_o_s | _F_u_n_c_t_i_o_n_s
│ │ │ │ │ -generics.h File Reference
│ │ │ │ │ -Generic templates for C++. _M_o_r_e_._._.
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_c_p_r_._h>
│ │ │ │ │ -#include 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,17 +3,17 @@
│ │ │ │ │ * _N_a_m_e_s_p_a_c_e_s
│ │ │ │ │ * _D_a_t_a_ _S_t_r_u_c_t_u_r_e_s
│ │ │ │ │ * _F_i_l_e_s
│ │ │ │ │ * _E_x_a_m_p_l_e_s
│ │ │ │ │ * _F_i_l_e_ _L_i_s_t
│ │ │ │ │ * _G_l_o_b_a_l_s
│ │ │ │ │ * _u_c_o_m_m_o_n
│ │ │ │ │ -generics.h
│ │ │ │ │ +secure.h
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _d_o_c_u_m_e_n_t_a_t_i_o_n_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ -1// Copyright (C) 2006-2014 David Sugar, Tycho Softworks.
│ │ │ │ │ +1// Copyright (C) 2010-2014 David Sugar, Tycho Softworks.
│ │ │ │ │ 2// Copyright (C) 2015-2020 Cherokees of Idaho.
│ │ │ │ │ 3//
│ │ │ │ │ 4// This file is part of GNU uCommon C++.
│ │ │ │ │ 5//
│ │ │ │ │ 6// GNU uCommon C++ is free software: you can redistribute it and/or modify
│ │ │ │ │ 7// it under the terms of the GNU Lesser General Public License as published
│ │ │ │ │ 8// by the Free Software Foundation, either version 3 of the License, or
│ │ │ │ │ @@ -23,458 +23,744 @@
│ │ │ │ │ 12// but WITHOUT ANY WARRANTY; without even the implied warranty of
│ │ │ │ │ 13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
│ │ │ │ │ 14// GNU Lesser General Public License for more details.
│ │ │ │ │ 15//
│ │ │ │ │ 16// You should have received a copy of the GNU Lesser General Public License
│ │ │ │ │ 17// along with GNU uCommon C++. If not, see A thread-safe atomic heap management system. │ │ │ │ +
Linked objects, lists, templates, and containers. │ │ │ │ More...
│ │ │ │ -#include <ucommon/cpr.h>#include <ucommon/atomic.h>#include <ucommon/protocols.h>#include <ucommon/generics.h>#include <ucommon/platform.h>#include <ucommon/object.h>#include <ucommon/thread.h>Go to the source code of this file.
│ │ │ ││ │ │ │ +Data Structures | |
| class | ucommon::linked_pointer< T > |
| A smart pointer template for iterating linked lists. More... | |
| class | ucommon::linked_value< T, O > |
| A linked object base class for ordered objects. More... | |
| class | ucommon::treemap< T > |
| Embed data objects into a tree structured memory database. More... | |
│ │ │ │ Namespaces | |
| namespace | ucommon |
| Common namespace for all ucommon objects. | |
│ │ │ │ Typedefs | |
| typedef typeref< Type::Bools > | ucommon::boolref_t |
| typedef const uint8_t * | ucommon::Type::Bools |
| typedef typeref< Type::Bytes > | ucommon::byteref_t |
| typedef const uint8_t * | ucommon::Type::Bytes |
| typedef typeref< Type::Bytes >::value * | ucommon::bytevalues_t |
| typedef const char * | ucommon::Type::Chars |
| typedef typeref< Type::Chars >::value * | ucommon::charvalues_t |
| typedef int32_t | ucommon::Type::Integer |
| typedef double | ucommon::Type::Real |
| typedef typeref< Type::Chars > | ucommon::stringref_t |
| typedef LinkedObject * | ucommon::LinkedIndex |
| Convenience typedef for root pointers of single linked lists. | |
| typedef DLinkedObject | ucommon::LinkedList |
│ │ │ │ Functions | |
| class | ucommon::__attribute__ ((visibility("default"))) ExclusiveProtocol |
| An exclusive locking protocol interface base. | |
| template<typename T > | |
| typeref< T > | ucommon::typeref_cast (T x) |
A thread-safe atomic heap management system.
│ │ │ │ -This is used to manage immutable heap instances of object types that are reference counted and automatically deleted when no longer used. All references to the object are through smart typeref pointers. Both specific classes for strings and byte arrays, and generic templates to support generic types in the heap are offered.
│ │ │ │ - │ │ │ │ -Definition in file typeref.h.
│ │ │ │ -| typedef const uint8_t* ucommon::Type::Bools | │ │ │ │ -
| typedef const uint8_t* ucommon::Type::Bytes | │ │ │ │ -
Linked objects, lists, templates, and containers.
│ │ │ │ +Common support for objects that might be organized as single and double linked lists, rings and queues, and tree oriented data structures. These generic classes may be used to help form anything from callback registration systems and indexed memory hashes to xml parsed tree nodes.
│ │ │ │ │ │ │ │ -| typedef const char* ucommon::Type::Chars | │ │ │ │ -
| typedef int32_t ucommon::Type::Integer | │ │ │ │ -
Definition in file linked.h.
│ │ │ │ + 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,82 +3,53 @@
│ │ │ │ │ * _N_a_m_e_s_p_a_c_e_s
│ │ │ │ │ * _D_a_t_a_ _S_t_r_u_c_t_u_r_e_s
│ │ │ │ │ * _F_i_l_e_s
│ │ │ │ │ * _E_x_a_m_p_l_e_s
│ │ │ │ │ * _F_i_l_e_ _L_i_s_t
│ │ │ │ │ * _G_l_o_b_a_l_s
│ │ │ │ │ * _u_c_o_m_m_o_n
│ │ │ │ │ -_N_a_m_e_s_p_a_c_e_s | _T_y_p_e_d_e_f_s | _F_u_n_c_t_i_o_n_s
│ │ │ │ │ -typeref.h File Reference
│ │ │ │ │ -A thread-safe atomic heap management system. _M_o_r_e_._._.
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_c_p_r_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_a_t_o_m_i_c_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_p_r_o_t_o_c_o_l_s_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_g_e_n_e_r_i_c_s_._h>
│ │ │ │ │ +_D_a_t_a_ _S_t_r_u_c_t_u_r_e_s | _N_a_m_e_s_p_a_c_e_s | _T_y_p_e_d_e_f_s | _F_u_n_c_t_i_o_n_s
│ │ │ │ │ +linked.h File Reference
│ │ │ │ │ +Linked objects, lists, templates, and containers. _M_o_r_e_._._.
│ │ │ │ │ +#include <_u_c_o_m_m_o_n_/_p_l_a_t_f_o_r_m_._h>
│ │ │ │ │ #include <_u_c_o_m_m_o_n_/_o_b_j_e_c_t_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_t_h_r_e_a_d_._h>
│ │ │ │ │ -Include dependency graph for typeref.h:
│ │ │ │ │ +Include dependency graph for linked.h:
│ │ │ │ │ TThhiiss bbrroowwsseerr iiss nnoott aabbllee ttoo sshhooww SSVVGG:: ttrryy FFiirreeffooxx,, CChhrroommee,, SSaaffaarrii,, oorr OOppeerraa
│ │ │ │ │ iinnsstteeaadd..
│ │ │ │ │ This graph shows which files directly or indirectly include this file:
│ │ │ │ │ TThhiiss bbrroowwsseerr iiss nnoott aabbllee ttoo sshhooww SSVVGG:: ttrryy FFiirreeffooxx,, CChhrroommee,, SSaaffaarrii,, oorr OOppeerraa
│ │ │ │ │ iinnsstteeaadd..
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _s_o_u_r_c_e_ _c_o_d_e_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ +DDaattaa SSttrruuccttuurreess
│ │ │ │ │ +class _u_c_o_m_m_o_n_:_:_l_i_n_k_e_d___p_o_i_n_t_e_r_<_ _T_ _>
│ │ │ │ │ + A smart pointer template for iterating linked lists. _M_o_r_e_._._.
│ │ │ │ │ +
│ │ │ │ │ +class _u_c_o_m_m_o_n_:_:_l_i_n_k_e_d___v_a_l_u_e_<_ _T_,_ _O_ _>
│ │ │ │ │ + A linked object base class for ordered objects. _M_o_r_e_._._.
│ │ │ │ │ +
│ │ │ │ │ +class _u_c_o_m_m_o_n_:_:_t_r_e_e_m_a_p_<_ _T_ _>
│ │ │ │ │ + Embed data objects into a tree structured memory database. _M_o_r_e_._._.
│ │ │ │ │ +
│ │ │ │ │ NNaammeessppaacceess
│ │ │ │ │ namespace _u_c_o_m_m_o_n
│ │ │ │ │ Common namespace for all ucommon objects.
│ │ │ │ │
│ │ │ │ │ TTyyppeeddeeffss
│ │ │ │ │ - typedef typeref< Type::Bools > _u_c_o_m_m_o_n_:_:_b_o_o_l_r_e_f___t
│ │ │ │ │ -
│ │ │ │ │ - typedef const uint8_t * _u_c_o_m_m_o_n_:_:_T_y_p_e_:_:_B_o_o_l_s
│ │ │ │ │ -
│ │ │ │ │ - typedef typeref< Type::Bytes > _u_c_o_m_m_o_n_:_:_b_y_t_e_r_e_f___t
│ │ │ │ │ -
│ │ │ │ │ - typedef const uint8_t * _u_c_o_m_m_o_n_:_:_T_y_p_e_:_:_B_y_t_e_s
│ │ │ │ │ +typedef LinkedObject * _u_c_o_m_m_o_n_:_:_L_i_n_k_e_d_I_n_d_e_x
│ │ │ │ │ + Convenience typedef for root pointers of single linked
│ │ │ │ │ + lists.
│ │ │ │ │
│ │ │ │ │ -typedef typeref< Type::Bytes >::value * _u_c_o_m_m_o_n_:_:_b_y_t_e_v_a_l_u_e_s___t
│ │ │ │ │ -
│ │ │ │ │ - typedef const char * _u_c_o_m_m_o_n_:_:_T_y_p_e_:_:_C_h_a_r_s
│ │ │ │ │ -
│ │ │ │ │ -typedef typeref< Type::Chars >::value * _u_c_o_m_m_o_n_:_:_c_h_a_r_v_a_l_u_e_s___t
│ │ │ │ │ -
│ │ │ │ │ - typedef int32_t _u_c_o_m_m_o_n_:_:_T_y_p_e_:_:_I_n_t_e_g_e_r
│ │ │ │ │ -
│ │ │ │ │ - typedef double _u_c_o_m_m_o_n_:_:_T_y_p_e_:_:_R_e_a_l
│ │ │ │ │ -
│ │ │ │ │ - typedef typeref< Type::Chars > _u_c_o_m_m_o_n_:_:_s_t_r_i_n_g_r_e_f___t
│ │ │ │ │ + typedef DLinkedObject _u_c_o_m_m_o_n_:_:_L_i_n_k_e_d_L_i_s_t
│ │ │ │ │
│ │ │ │ │ FFuunnccttiioonnss
│ │ │ │ │ - class _u_c_o_m_m_o_n_:_:_____a_t_t_r_i_b_u_t_e____ ((visibility("default")))
│ │ │ │ │ - ExclusiveProtocol
│ │ │ │ │ - An exclusive locking protocol interface base.
│ │ │ │ │ -
│ │ │ │ │ -template 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,680 +3,868 @@
│ │ │ │ │ * _N_a_m_e_s_p_a_c_e_s
│ │ │ │ │ * _D_a_t_a_ _S_t_r_u_c_t_u_r_e_s
│ │ │ │ │ * _F_i_l_e_s
│ │ │ │ │ * _E_x_a_m_p_l_e_s
│ │ │ │ │ * _F_i_l_e_ _L_i_s_t
│ │ │ │ │ * _G_l_o_b_a_l_s
│ │ │ │ │ * _u_c_o_m_m_o_n
│ │ │ │ │ -typeref.h
│ │ │ │ │ +linked.h
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _d_o_c_u_m_e_n_t_a_t_i_o_n_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ -1// Copyright (C) 2015-2020 Cherokees of Idaho.
│ │ │ │ │ -2//
│ │ │ │ │ -3// This file is part of GNU uCommon C++.
│ │ │ │ │ -4//
│ │ │ │ │ -5// GNU uCommon C++ is free software: you can redistribute it and/or modify
│ │ │ │ │ -6// it under the terms of the GNU Lesser General Public License as published
│ │ │ │ │ -7// by the Free Software Foundation, either version 3 of the License, or
│ │ │ │ │ -8// (at your option) any later version.
│ │ │ │ │ -9//
│ │ │ │ │ -10// GNU uCommon C++ is distributed in the hope that it will be useful,
│ │ │ │ │ -11// but WITHOUT ANY WARRANTY; without even the implied warranty of
│ │ │ │ │ -12// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
│ │ │ │ │ -13// GNU Lesser General Public License for more details.
│ │ │ │ │ -14//
│ │ │ │ │ -15// You should have received a copy of the GNU Lesser General Public License
│ │ │ │ │ -16// along with GNU uCommon C++. If not, see .
.
.
..
..
Temporary templates for C++. │ │ │ │ +
Generic templates for C++. │ │ │ │ More...
│ │ │ │ -#include <ucommon/platform.h>#include <ucommon/protocols.h>#include <ucommon/thread.h>#include <ucommon/string.h>#include <ucommon/memory.h>#include <ucommon/fsys.h>#include <ucommon/cpr.h>#include <cstdlib>#include <cstring>#include <stdexcept>Go to the source code of this file.
│ │ │ ││ │ │ │ Data Structures | |
| class | ucommon::temporary< T > |
| Manage temporary object stored on the heap. More... | |
| class | ucommon::array_pointer< T > |
| Generic smart array class. More... | |
| class | ucommon::pointer< T > |
| Generic smart pointer class. More... | |
| class | ucommon::save_restore< T > |
| Save and restore global objects in function call stack frames. More... | |
│ │ │ │ Namespaces | |
| namespace | ucommon |
| Common namespace for all ucommon objects. | |
| #define | THROW(x) throw x |
| #define | THROWS(x) throw(x) |
| #define | THROWS_ANY throw() |
│ │ │ │ +Functions | |
| template<typename T > | |
| bool | ucommon::bound (const T *pointer, const T *base, size_t count) |
| Convenience function to check memory arrays. | |
| template<typename T > | |
| T & | ucommon::clear (T &o) |
| template<typename T > | |
| T | ucommon::copy (const T &src) |
| Convenience function to copy objects. | |
| template<typename T > | |
| T & | ucommon::copy (const T &src, T &to) |
| template<typename T > | |
| void | ucommon::copy_unsafe (T *target, const T *source) |
| Convenience function to copy class. | |
| template<typename T > | |
| T & | ucommon::deref_pointer (T *pointer) |
| Convert a pointer to a reference with type checking. | |
| template<typename T > | |
| T * | ucommon::dup (const T &object) |
| Convenience function to duplicate object pointer to heap. | |
| template<> | |
| char * | ucommon::dup< char > (const char &object) |
| template<typename T > | |
| void | ucommon::dupfree (T object) |
| template<> | |
| void | ucommon::dupfree< char * > (char *object) |
| template<typename T > | |
| bool | ucommon::is (T &object) |
| Convenience function to validate object assuming it is castable to bool. | |
| template<typename T > | |
| bool | ucommon::isnull (T &object) |
| Convenience function to test pointer object. | |
| template<typename T > | |
| bool | ucommon::isnullp (T *object) |
| Convenience function to test pointer-pointer object. | |
| template<typename T > | |
| T &() | ucommon::limit (T &value, T &low, T &high) |
| Convenience macro to range restrict values. | |
| template<typename T > | |
| T &() | ucommon::max (T &o1, T &o2) |
| Convenience function to return max of two objects. | |
| template<typename T > | |
| T &() | ucommon::min (T &o1, T &o2) |
| Convenience function to return min of two objects. | |
| template<typename T > | |
| T & | ucommon::move (T &src, T &to) |
| Convenience function to move objects. | |
| template<typename T > | |
| void | ucommon::reset_unsafe (T &object) |
| Convenience function to reset an existing object. | |
| template<typename T > | |
| void | ucommon::store_unsafe (T &target, const T *source) |
| Convenience function to store object pointer into object. | |
| template<typename T > | |
| void | ucommon::swap (T &o1, T &o2) |
| Convenience function to swap objects. | |
| template<typename T > | |
| void | ucommon::zero_unsafe (T &object) |
| Convenience function to zero an object and restore type info. | |
Temporary templates for C++.
│ │ │ │ -This offers automatic management of heap temporary objects.
│ │ │ │ +Generic templates for C++.
│ │ │ │ +These are templates that do not depend on any ucommon classes. They can be used for generic C++ programming.
│ │ │ │ │ │ │ │ -Definition in file temporary.h.
│ │ │ │ +Definition in file generics.h.
│ │ │ │| │ │ │ │ | x | ) | │ │ │ │throw x | │ │ │ │ │ │ │ │
Definition at line 57 of file temporary.h.
│ │ │ │ +Definition at line 37 of file generics.h.
│ │ │ │ │ │ │ │Definition at line 62 of file temporary.h.
│ │ │ │ +Definition at line 42 of file generics.h.
│ │ │ │ │ │ │ │| #define THROWS_ANY throw() | │ │ │ │
Definition at line 63 of file temporary.h.
│ │ │ │ +Definition at line 43 of file generics.h.
│ │ │ │ │ │ │ │ 1.9.8
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,57 +3,140 @@
│ │ │ │ │ * _N_a_m_e_s_p_a_c_e_s
│ │ │ │ │ * _D_a_t_a_ _S_t_r_u_c_t_u_r_e_s
│ │ │ │ │ * _F_i_l_e_s
│ │ │ │ │ * _E_x_a_m_p_l_e_s
│ │ │ │ │ * _F_i_l_e_ _L_i_s_t
│ │ │ │ │ * _G_l_o_b_a_l_s
│ │ │ │ │ * _u_c_o_m_m_o_n
│ │ │ │ │ -_D_a_t_a_ _S_t_r_u_c_t_u_r_e_s | _N_a_m_e_s_p_a_c_e_s | _M_a_c_r_o_s
│ │ │ │ │ -temporary.h File Reference
│ │ │ │ │ -Temporary templates for C++. _M_o_r_e_._._.
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_p_l_a_t_f_o_r_m_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_p_r_o_t_o_c_o_l_s_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_t_h_r_e_a_d_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_s_t_r_i_n_g_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_m_e_m_o_r_y_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_f_s_y_s_._h>
│ │ │ │ │ +_D_a_t_a_ _S_t_r_u_c_t_u_r_e_s | _N_a_m_e_s_p_a_c_e_s | _M_a_c_r_o_s | _F_u_n_c_t_i_o_n_s
│ │ │ │ │ +generics.h File Reference
│ │ │ │ │ +Generic templates for C++. _M_o_r_e_._._.
│ │ │ │ │ +#include <_u_c_o_m_m_o_n_/_c_p_r_._h>
│ │ │ │ │ #include 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,15 +3,15 @@
│ │ │ │ │ * _N_a_m_e_s_p_a_c_e_s
│ │ │ │ │ * _D_a_t_a_ _S_t_r_u_c_t_u_r_e_s
│ │ │ │ │ * _F_i_l_e_s
│ │ │ │ │ * _E_x_a_m_p_l_e_s
│ │ │ │ │ * _F_i_l_e_ _L_i_s_t
│ │ │ │ │ * _G_l_o_b_a_l_s
│ │ │ │ │ * _u_c_o_m_m_o_n
│ │ │ │ │ -temporary.h
│ │ │ │ │ +generics.h
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _d_o_c_u_m_e_n_t_a_t_i_o_n_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ 1// Copyright (C) 2006-2014 David Sugar, Tycho Softworks.
│ │ │ │ │ 2// Copyright (C) 2015-2020 Cherokees of Idaho.
│ │ │ │ │ 3//
│ │ │ │ │ 4// This file is part of GNU uCommon C++.
│ │ │ │ │ 5//
│ │ │ │ │ 6// GNU uCommon C++ is free software: you can redistribute it and/or modify
│ │ │ │ │ @@ -23,345 +23,458 @@
│ │ │ │ │ 12// but WITHOUT ANY WARRANTY; without even the implied warranty of
│ │ │ │ │ 13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
│ │ │ │ │ 14// GNU Lesser General Public License for more details.
│ │ │ │ │ 15//
│ │ │ │ │ 16// You should have received a copy of the GNU Lesser General Public License
│ │ │ │ │ 17// along with GNU uCommon C++. If not, see .
.
.
..
.Support for memory mapped objects. │ │ │ │ +
Maps of thread-safe strongly typed heap objects. │ │ │ │ More...
│ │ │ │ -#include <ucommon/linked.h>#include <ucommon/cpr.h>#include <ucommon/atomic.h>#include <ucommon/protocols.h>#include <ucommon/object.h>#include <ucommon/typeref.h>#include <ucommon/linked.h>#include <ucommon/thread.h>#include <ucommon/string.h>#include <signal.h>Go to the source code of this file.
│ │ │ ││ │ │ │ -Data Structures | |
| class | ucommon::mapped_array< T > |
| Map a reusable allocator over a named shared memory segment. More... | |
| class | ucommon::mapped_reuse< T > |
| Template class to map typed reusable objects into shared memory heap. More... | |
| class | ucommon::mapped_view< T > |
| Class to access a named mapped segment published from another process. More... | |
│ │ │ │ Namespaces | |
| namespace | ucommon |
| Common namespace for all ucommon objects. | |
│ │ │ │ Functions | |
| class | ucommon::__attribute__ ((visibility("default"))) ExclusiveProtocol |
| An exclusive locking protocol interface base. | |
| template<typename T > | |
| class __attribute__((visibility("default"))) MapRef size_t | ucommon::mapkeypath (typeref< T > &object) |
| template<> | |
| size_t | ucommon::mapkeypath< const char * > (typeref< const char * > &object) |
| template<> | |
| size_t | ucommon::mapkeypath< const uint8_t * > (typeref< const uint8_t * > &object) |
Support for memory mapped objects.
│ │ │ │ -Memory mapped objects can be used to publish information so that it may be accessible directly by external programs. The mapped memory objects will usually be built as a vector vector or reusable type factory, in the latter case using the allocated shared memory block itself as a local heap. A simple template can be used to view the mapped contents that have been published by another process.
│ │ │ │ +Maps of thread-safe strongly typed heap objects.
│ │ │ │ +This is used for maps of smart pointers to immutable heap instances of object types. Shared and exclusive locking is used based on lookup or modify operations.
│ │ │ │ │ │ │ │ -Definition in file mapped.h.
│ │ │ │ +Definition in file mapref.h.
│ │ │ │ 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,52 +3,49 @@
│ │ │ │ │ * _N_a_m_e_s_p_a_c_e_s
│ │ │ │ │ * _D_a_t_a_ _S_t_r_u_c_t_u_r_e_s
│ │ │ │ │ * _F_i_l_e_s
│ │ │ │ │ * _E_x_a_m_p_l_e_s
│ │ │ │ │ * _F_i_l_e_ _L_i_s_t
│ │ │ │ │ * _G_l_o_b_a_l_s
│ │ │ │ │ * _u_c_o_m_m_o_n
│ │ │ │ │ -_D_a_t_a_ _S_t_r_u_c_t_u_r_e_s | _N_a_m_e_s_p_a_c_e_s | _F_u_n_c_t_i_o_n_s
│ │ │ │ │ -mapped.h File Reference
│ │ │ │ │ -Support for memory mapped objects. _M_o_r_e_._._.
│ │ │ │ │ +_N_a_m_e_s_p_a_c_e_s | _F_u_n_c_t_i_o_n_s
│ │ │ │ │ +mapref.h File Reference
│ │ │ │ │ +Maps of thread-safe strongly typed heap objects. _M_o_r_e_._._.
│ │ │ │ │ +#include <_u_c_o_m_m_o_n_/_c_p_r_._h>
│ │ │ │ │ +#include <_u_c_o_m_m_o_n_/_a_t_o_m_i_c_._h>
│ │ │ │ │ +#include <_u_c_o_m_m_o_n_/_p_r_o_t_o_c_o_l_s_._h>
│ │ │ │ │ +#include <_u_c_o_m_m_o_n_/_o_b_j_e_c_t_._h>
│ │ │ │ │ +#include <_u_c_o_m_m_o_n_/_t_y_p_e_r_e_f_._h>
│ │ │ │ │ #include <_u_c_o_m_m_o_n_/_l_i_n_k_e_d_._h>
│ │ │ │ │ #include <_u_c_o_m_m_o_n_/_t_h_r_e_a_d_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_s_t_r_i_n_g_._h>
│ │ │ │ │ -#include 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,368 +3,507 @@
│ │ │ │ │ * _N_a_m_e_s_p_a_c_e_s
│ │ │ │ │ * _D_a_t_a_ _S_t_r_u_c_t_u_r_e_s
│ │ │ │ │ * _F_i_l_e_s
│ │ │ │ │ * _E_x_a_m_p_l_e_s
│ │ │ │ │ * _F_i_l_e_ _L_i_s_t
│ │ │ │ │ * _G_l_o_b_a_l_s
│ │ │ │ │ * _u_c_o_m_m_o_n
│ │ │ │ │ -mapped.h
│ │ │ │ │ +mapref.h
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _d_o_c_u_m_e_n_t_a_t_i_o_n_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ -1// Copyright (C) 2006-2014 David Sugar, Tycho Softworks.
│ │ │ │ │ -2// Copyright (C) 2015-2020 Cherokees of Idaho.
│ │ │ │ │ -3//
│ │ │ │ │ -4// This file is part of GNU uCommon C++.
│ │ │ │ │ -5//
│ │ │ │ │ -6// GNU uCommon C++ is free software: you can redistribute it and/or modify
│ │ │ │ │ -7// it under the terms of the GNU Lesser General Public License as published
│ │ │ │ │ -8// by the Free Software Foundation, either version 3 of the License, or
│ │ │ │ │ -9// (at your option) any later version.
│ │ │ │ │ -10//
│ │ │ │ │ -11// GNU uCommon C++ is distributed in the hope that it will be useful,
│ │ │ │ │ -12// but WITHOUT ANY WARRANTY; without even the implied warranty of
│ │ │ │ │ -13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
│ │ │ │ │ -14// GNU Lesser General Public License for more details.
│ │ │ │ │ -15//
│ │ │ │ │ -16// You should have received a copy of the GNU Lesser General Public License
│ │ │ │ │ -17// along with GNU uCommon C++. If not, see .
.Top level include file for the GNU uCommon C++ core library. │ │ │ │ +
Parsing of config files that have keyword/value pairs. │ │ │ │ More...
│ │ │ │ -#include <ucommon/platform.h>#include <ucommon/cpr.h>#include <ucommon/atomic.h>#include <ucommon/generics.h>#include <ucommon/protocols.h>#include <ucommon/object.h>#include <ucommon/typeref.h>#include <ucommon/string.h>#include <ucommon/counter.h>#include <ucommon/numbers.h>#include <ucommon/reuse.h>#include <ucommon/linked.h>#include <ucommon/timers.h>#include <ucommon/access.h>#include <ucommon/memory.h>#include <ucommon/mapped.h>#include <ucommon/unicode.h>#include <ucommon/datetime.h>#include <ucommon/keydata.h>#include <ucommon/socket.h>#include <ucommon/condition.h>#include <ucommon/thread.h>#include <ucommon/arrayref.h>#include <ucommon/mapref.h>#include <ucommon/shared.h>#include <ucommon/fsys.h>#include <ucommon/temporary.h>#include <ucommon/shell.h>#include <ucommon/stream.h>#include <ucommon/stl.h>#include <ucommon/platform.h>#include <ucommon/linked.h>#include <ucommon/memory.h>Go to the source code of this file.
│ │ │ │ +│ │ │ │ +Namespaces | |
| namespace | ucommon |
| Common namespace for all ucommon objects. | |
Top level include file for the GNU uCommon C++ core library.
│ │ │ │ -This is the only include file you need to have in your sources; it includes the remaining header files.
│ │ │ │ + 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,53 +3,31 @@
│ │ │ │ │ * _N_a_m_e_s_p_a_c_e_s
│ │ │ │ │ * _D_a_t_a_ _S_t_r_u_c_t_u_r_e_s
│ │ │ │ │ * _F_i_l_e_s
│ │ │ │ │ * _E_x_a_m_p_l_e_s
│ │ │ │ │ * _F_i_l_e_ _L_i_s_t
│ │ │ │ │ * _G_l_o_b_a_l_s
│ │ │ │ │ * _u_c_o_m_m_o_n
│ │ │ │ │ -ucommon.h File Reference
│ │ │ │ │ -Top level include file for the GNU uCommon C++ core library. _M_o_r_e_._._.
│ │ │ │ │ +_N_a_m_e_s_p_a_c_e_s
│ │ │ │ │ +keydata.h File Reference
│ │ │ │ │ +Parsing of config files that have keyword/value pairs. _M_o_r_e_._._.
│ │ │ │ │ #include <_u_c_o_m_m_o_n_/_p_l_a_t_f_o_r_m_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_c_p_r_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_a_t_o_m_i_c_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_g_e_n_e_r_i_c_s_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_p_r_o_t_o_c_o_l_s_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_o_b_j_e_c_t_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_t_y_p_e_r_e_f_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_s_t_r_i_n_g_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_c_o_u_n_t_e_r_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_n_u_m_b_e_r_s_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_r_e_u_s_e_._h>
│ │ │ │ │ #include <_u_c_o_m_m_o_n_/_l_i_n_k_e_d_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_t_i_m_e_r_s_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_a_c_c_e_s_s_._h>
│ │ │ │ │ #include <_u_c_o_m_m_o_n_/_m_e_m_o_r_y_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_m_a_p_p_e_d_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_u_n_i_c_o_d_e_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_d_a_t_e_t_i_m_e_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_k_e_y_d_a_t_a_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_s_o_c_k_e_t_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_c_o_n_d_i_t_i_o_n_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_t_h_r_e_a_d_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_a_r_r_a_y_r_e_f_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_m_a_p_r_e_f_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_s_h_a_r_e_d_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_f_s_y_s_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_t_e_m_p_o_r_a_r_y_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_s_h_e_l_l_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_s_t_r_e_a_m_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_s_t_l_._h>
│ │ │ │ │ -Include dependency graph for ucommon.h:
│ │ │ │ │ +Include dependency graph for keydata.h:
│ │ │ │ │ TThhiiss bbrroowwsseerr iiss nnoott aabbllee ttoo sshhooww SSVVGG:: ttrryy FFiirreeffooxx,, CChhrroommee,, SSaaffaarrii,, oorr OOppeerraa
│ │ │ │ │ iinnsstteeaadd..
│ │ │ │ │ This graph shows which files directly or indirectly include this file:
│ │ │ │ │ TThhiiss bbrroowwsseerr iiss nnoott aabbllee ttoo sshhooww SSVVGG:: ttrryy FFiirreeffooxx,, CChhrroommee,, SSaaffaarrii,, oorr OOppeerraa
│ │ │ │ │ iinnsstteeaadd..
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _s_o_u_r_c_e_ _c_o_d_e_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ +NNaammeessppaacceess
│ │ │ │ │ +namespace _u_c_o_m_m_o_n
│ │ │ │ │ + Common namespace for all ucommon objects.
│ │ │ │ │ +
│ │ │ │ │ ********** DDeettaaiilleedd DDeessccrriippttiioonn **********
│ │ │ │ │ -Top level include file for the GNU uCommon C++ core library.
│ │ │ │ │ -This is the only include file you need to have in your sources; it includes the
│ │ │ │ │ -remaining header files.
│ │ │ │ │ -Definition in file _u_c_o_m_m_o_n_._h.
│ │ │ │ │ +Parsing of config files that have keyword/value pairs.
│ │ │ │ │ +This includes supporting classes to extract basic config data from files that
│ │ │ │ │ +are stored as []'s, and uses several supporting classes.
│ │ │ │ │ +Definition in file _k_e_y_d_a_t_a_._h.
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8
│ │ │ ├── ./usr/share/doc/ucommon-doc/html/a00419_source.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ - 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,15 +3,15 @@
│ │ │ │ │ * _N_a_m_e_s_p_a_c_e_s
│ │ │ │ │ * _D_a_t_a_ _S_t_r_u_c_t_u_r_e_s
│ │ │ │ │ * _F_i_l_e_s
│ │ │ │ │ * _E_x_a_m_p_l_e_s
│ │ │ │ │ * _F_i_l_e_ _L_i_s_t
│ │ │ │ │ * _G_l_o_b_a_l_s
│ │ │ │ │ * _u_c_o_m_m_o_n
│ │ │ │ │ -ucommon.h
│ │ │ │ │ +keydata.h
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _d_o_c_u_m_e_n_t_a_t_i_o_n_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ 1// Copyright (C) 2006-2014 David Sugar, Tycho Softworks.
│ │ │ │ │ 2// Copyright (C) 2015-2020 Cherokees of Idaho.
│ │ │ │ │ 3//
│ │ │ │ │ 4// This file is part of GNU uCommon C++.
│ │ │ │ │ 5//
│ │ │ │ │ 6// GNU uCommon C++ is free software: you can redistribute it and/or modify
│ │ │ │ │ @@ -23,108 +23,164 @@
│ │ │ │ │ 12// but WITHOUT ANY WARRANTY; without even the implied warranty of
│ │ │ │ │ 13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
│ │ │ │ │ 14// GNU Lesser General Public License for more details.
│ │ │ │ │ 15//
│ │ │ │ │ 16// You should have received a copy of the GNU Lesser General Public License
│ │ │ │ │ 17// along with GNU uCommon C++. If not, see .
..
.Thread-aware file system manipulation class. │ │ │ │ +
Basic array and reusable object factory heap support. │ │ │ │ More...
│ │ │ │ -#include <ucommon/platform.h>#include <ucommon/protocols.h>#include <ucommon/thread.h>#include <ucommon/typeref.h>#include <ucommon/memory.h>#include <sys/stat.h>#include <errno.h>#include <stdio.h>#include <ucommon/thread.h>Go to the source code of this file.
│ │ │ ││ │ │ │ +Data Structures | |
| class | ucommon::array_reuse< T > |
| An array of reusable objects. More... | |
| class | ucommon::paged_reuse< T > |
| A reusable private pool of reusable types. More... | |
│ │ │ │ Namespaces | |
| namespace | ucommon |
| Common namespace for all ucommon objects. | |
│ │ │ │ -Macros | |
| #define | __S_ISTYPE(mode, mask) (((mode) & S_IFMT) == (mask)) |
| #define | S_ISBLK(mode) 0 |
| #define | S_ISCHR(mode) 0 |
| #define | S_ISFIFO(mode) (0) |
| #define | S_ISLNK(mode) (0) |
| #define | S_ISREG(mode) 1 |
| #define | S_ISSOCK(mode) (0) |
│ │ │ │ Typedefs | |
| typedef dir | ucommon::dir_t |
| typedef dso | ucommon::dso_t |
| typedef void * | ucommon::mem_t |
| Convenience type for loader operations. | |
│ │ │ │ -Functions | |
| class | ucommon::__attribute__ ((visibility("default"))) ExclusiveProtocol |
| An exclusive locking protocol interface base. | |
| bool | ucommon::is_device (const char *path) |
| bool | ucommon::is_dir (const char *path) |
| bool | ucommon::is_executable (const char *path) |
| bool | ucommon::is_exists (const char *path) |
| bool | ucommon::is_file (const char *path) |
| bool | ucommon::is_link (const char *path) |
| bool | ucommon::is_readable (const char *path) |
| bool | ucommon::is_writable (const char *path) |
│ │ │ │ -Variables | |
| class __attribute__((visibility("default"))) dir typedef fsys | ucommon::fsys_t |
| Convenience class for directories. | |
| typedef unsigned short | ucommon::vectorsize_t |
Thread-aware file system manipulation class.
│ │ │ │ -This is used to provide generic file operations that are OS independent and thread-safe in behavior. This is used in particular to wrap posix calls internally to pth, and to create portable code between MSWINDOWS and Posix low-level file I/O operations.
│ │ │ │ +Basic array and reusable object factory heap support.
│ │ │ │ +This offers ucommon support for forming reusable object pools. Reusable object pools can be tied to local heaps and offer a means to create type factories that do not require global locking through malloc.
│ │ │ │ │ │ │ │ -Definition in file fsys.h.
│ │ │ │ -| #define __S_ISTYPE | │ │ │ │ -( | │ │ │ │ -│ │ │ │ - | mode, | │ │ │ │ -
| │ │ │ │ - | │ │ │ │ - | │ │ │ │ - | mask | │ │ │ │ -
| │ │ │ │ - | ) | │ │ │ │ -(((mode) & S_IFMT) == (mask)) | │ │ │ │ -
| #define S_ISBLK | │ │ │ │ -( | │ │ │ │ -│ │ │ │ - | mode | ) | │ │ │ │ -0 | │ │ │ │ -
| #define S_ISCHR | │ │ │ │ -( | │ │ │ │ -│ │ │ │ - | mode | ) | │ │ │ │ -0 | │ │ │ │ -
| #define S_ISFIFO | │ │ │ │ -( | │ │ │ │ -│ │ │ │ - | mode | ) | │ │ │ │ -(0) | │ │ │ │ -
| #define S_ISLNK | │ │ │ │ -( | │ │ │ │ -│ │ │ │ - | mode | ) | │ │ │ │ -(0) | │ │ │ │ -
| #define S_ISREG | │ │ │ │ -( | │ │ │ │ -│ │ │ │ - | mode | ) | │ │ │ │ -1 | │ │ │ │ -
Definition in file reuse.h.
│ │ │ │ + 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,110 +3,40 @@
│ │ │ │ │ * _N_a_m_e_s_p_a_c_e_s
│ │ │ │ │ * _D_a_t_a_ _S_t_r_u_c_t_u_r_e_s
│ │ │ │ │ * _F_i_l_e_s
│ │ │ │ │ * _E_x_a_m_p_l_e_s
│ │ │ │ │ * _F_i_l_e_ _L_i_s_t
│ │ │ │ │ * _G_l_o_b_a_l_s
│ │ │ │ │ * _u_c_o_m_m_o_n
│ │ │ │ │ -_N_a_m_e_s_p_a_c_e_s | _M_a_c_r_o_s | _T_y_p_e_d_e_f_s | _F_u_n_c_t_i_o_n_s | _V_a_r_i_a_b_l_e_s
│ │ │ │ │ -fsys.h File Reference
│ │ │ │ │ -Thread-aware file system manipulation class. _M_o_r_e_._._.
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_p_l_a_t_f_o_r_m_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_p_r_o_t_o_c_o_l_s_._h>
│ │ │ │ │ +_D_a_t_a_ _S_t_r_u_c_t_u_r_e_s | _N_a_m_e_s_p_a_c_e_s | _T_y_p_e_d_e_f_s
│ │ │ │ │ +reuse.h File Reference
│ │ │ │ │ +Basic array and reusable object factory heap support. _M_o_r_e_._._.
│ │ │ │ │ #include <_u_c_o_m_m_o_n_/_t_h_r_e_a_d_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_t_y_p_e_r_e_f_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_m_e_m_o_r_y_._h>
│ │ │ │ │ -#include 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,15 +3,15 @@
│ │ │ │ │ * _N_a_m_e_s_p_a_c_e_s
│ │ │ │ │ * _D_a_t_a_ _S_t_r_u_c_t_u_r_e_s
│ │ │ │ │ * _F_i_l_e_s
│ │ │ │ │ * _E_x_a_m_p_l_e_s
│ │ │ │ │ * _F_i_l_e_ _L_i_s_t
│ │ │ │ │ * _G_l_o_b_a_l_s
│ │ │ │ │ * _u_c_o_m_m_o_n
│ │ │ │ │ -fsys.h
│ │ │ │ │ +reuse.h
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _d_o_c_u_m_e_n_t_a_t_i_o_n_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ 1// Copyright (C) 2006-2014 David Sugar, Tycho Softworks.
│ │ │ │ │ 2// Copyright (C) 2015-2020 Cherokees of Idaho.
│ │ │ │ │ 3//
│ │ │ │ │ 4// This file is part of GNU uCommon C++.
│ │ │ │ │ 5//
│ │ │ │ │ 6// GNU uCommon C++ is free software: you can redistribute it and/or modify
│ │ │ │ │ @@ -23,488 +23,265 @@
│ │ │ │ │ 12// but WITHOUT ANY WARRANTY; without even the implied warranty of
│ │ │ │ │ 13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
│ │ │ │ │ 14// GNU Lesser General Public License for more details.
│ │ │ │ │ 15//
│ │ │ │ │ 16// You should have received a copy of the GNU Lesser General Public License
│ │ │ │ │ 17// along with GNU uCommon C++. If not, see .
..
.Abstract interfaces and support. │ │ │ │ +
Various miscellaneous platform specific headers and defines. │ │ │ │ More...
│ │ │ │ -#include <ucommon/cpr.h>#include <cstdlib>#include <cstddef>#include <stdexcept>#include <pthread.h>#include <signal.h>#include <sys/stat.h>#include <sys/types.h>#include <stdint.h>#include <unistd.h>#include <stdio.h>#include <cctype>#include <climits>#include <cerrno>#include <new>#include <assert.h>Go to the source code of this file.
│ │ │ ││ │ │ │ Namespaces | |
| namespace | ucommon |
| Common namespace for all ucommon objects. | |
│ │ │ │ +Macros | |
| #define | __ALIGNED(x) __attribute__(align(x)) |
| #define | __DELETE_COPY(x) |
| #define | __DELETE_DEFAULTS(x) |
| #define | __DELETED |
| #define | __EXPORT __attribute__ ((visibility("default"))) |
| #define | __FINAL |
| #define | __GNUC_PREREQ__(maj, min) 0 |
| #define | __LOCAL __attribute__ ((visibility("hidden"))) |
| #define | __MALLOC |
| #define | __OVERRIDE |
| #define | __PRINTF(x, y) |
| #define | __PROGRAM(c, v) extern "C" int main(int c, char **v) |
| #define | __PROTOCOL virtual |
| #define | __SCANF(x, y) |
| #define | __SERVICE(id, c, v) void service_##id(int c, char **v) |
| #define | __SHARED __attribute__ ((visibility("default"))) |
| #define | __THROW_ALLOC() throw std::bad_alloc() |
| #define | __THROW_DEREF(v) |
| #define | __THROW_RANGE(x) throw std::out_of_range(x) |
| #define | __THROW_RUNTIME(x) throw std::runtime_error(x) |
| #define | __THROW_SIZE(x) throw std::length_error(x) |
| #define | __THROW_UNDEF(v, x) if(v == nullptr) throw std::runtime_error(x) |
| #define | __UNUSED(x) (void)x |
| #define | _POSIX_PTHREAD_SEMANTICS |
| #define | _REENTRANT 1 |
| #define | _THREADSAFE 1 |
| #define | _UCOMMON_EXTENDED_ |
| #define | _UCOMMON_PLATFORM_H_ |
| #define | crit(x, text) if(!(x)) cpr_runtime_error(text) |
| #define | END_NAMESPACE } |
| #define | INVALID_HANDLE_VALUE -1 |
| #define | INVALID_SOCKET -1 |
| #define | NAMESPACE_UCOMMON namespace ucommon { |
| #define | NDEBUG |
| #define | PROGRAM_EXIT(code) return code |
| #define | PROGRAM_MAIN(argc, argv) extern "C" int main(int argc, char **argv) |
| #define | SERVICE_MAIN(id, argc, argv) void service_##id(int argc, char **argv) |
| #define | UCOMMON_ABI 7 |
| #define | UCOMMON_NAMESPACE ucommon |
| #define | UCOMMON_RTTI 1 |
│ │ │ │ +Typedefs | |
| typedef void(* | cpr_service_t) (int argc, char **argv) |
| typedef int | fd_t |
| typedef long | Integer |
| typedef double | Real |
| typedef void(* | sighandler_t) (int) |
| Convenient typedef for signal handlers. | |
| typedef int | socket_t |
| typedef size_t | socksize_t |
| typedef size_t | stacksize_t |
| typedef unsigned long | timeout_t |
| typedef uint8_t | ubyte_t |
| typedef unsigned long | Unsigned |
│ │ │ │ Functions | |
| class | ucommon::__attribute__ ((visibility("default"))) ExclusiveProtocol |
| An exclusive locking protocol interface base. | |
| template<typename T > | |
| const T | immutable_cast (T p) |
| template<class T > | |
| T * | init (T *memory) |
| Template function to initialize memory by invoking default constructor. | |
| template<class T , class S > | |
| T | polyconst_cast (S *s) |
| template<class T , class S > | |
| T | polydynamic_cast (S *s) |
| template<class T , class S > | |
| T | polypointer_cast (S *s) |
| template<class T , class S > | |
| T & | polyreference_cast (S *s) |
| template<class T , class S > | |
| T | polystatic_cast (S *s) |
| template<typename T , typename S > | |
| T | protocol_cast (S *s) |
| template<typename T > | |
| T & | reference_cast (T *pointer) |
| void | strfree (char *str) |
| Matching function for strdup(). | |
│ │ │ │ +Variables | |
| │ │ │ │ +const class nullptr_t | nullptr = {} |
Abstract interfaces and support.
│ │ │ │ -This is a set of "protocols", a concept borrowed from other object oriented languages, to define interfaces for low level services. By using a protocol base class which offers both virtuals and support methods only, one can easily stack and share these as common base classes without having to consider when the final derived object implements them. Core protocol methods always are tagged with a _ prefix to make it easier to track their derivation.
│ │ │ │ - │ │ │ │ +Various miscellaneous platform specific headers and defines.
│ │ │ │ +This is used to support ucommon on different platforms. The ucommon library assumes at least a real posix threading library is present or will build thread support native on Microsoft Windows legacy platform. This header also deals with issues related to common base types.
│ │ │ │ + │ │ │ │ +Definition in file platform.h.
│ │ │ │ +| #define __ALIGNED | │ │ │ │ +( | │ │ │ │ +│ │ │ │ + | x | ) | │ │ │ │ +__attribute__(align(x)) | │ │ │ │ +
Definition at line 167 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define __DELETE_COPY | │ │ │ │ +( | │ │ │ │ +│ │ │ │ + | x | ) | │ │ │ │ +│ │ │ │ + |
Definition at line 175 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define __DELETE_DEFAULTS | │ │ │ │ +( | │ │ │ │ +│ │ │ │ + | x | ) | │ │ │ │ +│ │ │ │ + |
Definition at line 177 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define __DELETED | │ │ │ │ +
Definition at line 174 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define __EXPORT __attribute__ ((visibility("default"))) | │ │ │ │ +
Definition at line 312 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define __FINAL | │ │ │ │ +
Definition at line 172 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define __GNUC_PREREQ__ | │ │ │ │ +( | │ │ │ │ +│ │ │ │ + | maj, | │ │ │ │ +
| │ │ │ │ + | │ │ │ │ + | │ │ │ │ + | min | │ │ │ │ +
| │ │ │ │ + | ) | │ │ │ │ +0 | │ │ │ │ +
Definition at line 148 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define __LOCAL __attribute__ ((visibility("hidden"))) | │ │ │ │ +
Definition at line 313 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define __MALLOC | │ │ │ │ +
Definition at line 216 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define __OVERRIDE | │ │ │ │ +
Definition at line 173 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define __PRINTF | │ │ │ │ +( | │ │ │ │ +│ │ │ │ + | x, | │ │ │ │ +
| │ │ │ │ + | │ │ │ │ + | │ │ │ │ + | y | │ │ │ │ +
| │ │ │ │ + | ) | │ │ │ │ +│ │ │ │ + |
Definition at line 214 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define __PROGRAM | │ │ │ │ +( | │ │ │ │ +│ │ │ │ + | c, | │ │ │ │ +
| │ │ │ │ + | │ │ │ │ + | │ │ │ │ + | v | │ │ │ │ +
| │ │ │ │ + | ) | │ │ │ │ +extern "C" int main(int c, char **v) | │ │ │ │ +
Definition at line 541 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define __PROTOCOL virtual | │ │ │ │ +
Definition at line 127 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define __SCANF | │ │ │ │ +( | │ │ │ │ +│ │ │ │ + | x, | │ │ │ │ +
| │ │ │ │ + | │ │ │ │ + | │ │ │ │ + | y | │ │ │ │ +
| │ │ │ │ + | ) | │ │ │ │ +│ │ │ │ + |
Definition at line 215 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define __SERVICE | │ │ │ │ +( | │ │ │ │ +│ │ │ │ + | id, | │ │ │ │ +
| │ │ │ │ + | │ │ │ │ + | │ │ │ │ + | c, | │ │ │ │ +
| │ │ │ │ + | │ │ │ │ + | │ │ │ │ + | v | │ │ │ │ +
| │ │ │ │ + | ) | │ │ │ │ +void service_##id(int c, char **v) | │ │ │ │ +
Definition at line 547 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define __SHARED __attribute__ ((visibility("default"))) | │ │ │ │ +
Definition at line 314 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define __THROW_ALLOC | │ │ │ │ +( | │ │ │ │ +) | │ │ │ │ +throw std::bad_alloc() | │ │ │ │ +
Definition at line 67 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define __THROW_DEREF | │ │ │ │ +( | │ │ │ │ +│ │ │ │ + | v | ) | │ │ │ │ +│ │ │ │ + |
Definition at line 68 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define __THROW_RANGE | │ │ │ │ +( | │ │ │ │ +│ │ │ │ + | x | ) | │ │ │ │ +throw std::out_of_range(x) | │ │ │ │ +
Definition at line 65 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define __THROW_RUNTIME | │ │ │ │ +( | │ │ │ │ +│ │ │ │ + | x | ) | │ │ │ │ +throw std::runtime_error(x) | │ │ │ │ +
Definition at line 66 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define __THROW_SIZE | │ │ │ │ +( | │ │ │ │ +│ │ │ │ + | x | ) | │ │ │ │ +throw std::length_error(x) | │ │ │ │ +
Definition at line 64 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define __THROW_UNDEF | │ │ │ │ +( | │ │ │ │ +│ │ │ │ + | v, | │ │ │ │ +
| │ │ │ │ + | │ │ │ │ + | │ │ │ │ + | x | │ │ │ │ +
| │ │ │ │ + | ) | │ │ │ │ +if(v == nullptr) throw std::runtime_error(x) | │ │ │ │ +
Definition at line 70 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define __UNUSED | │ │ │ │ +( | │ │ │ │ +│ │ │ │ + | x | ) | │ │ │ │ +(void)x | │ │ │ │ +
Definition at line 159 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define _POSIX_PTHREAD_SEMANTICS | │ │ │ │ +
Definition at line 104 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define _REENTRANT 1 | │ │ │ │ +
Definition at line 95 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define _THREADSAFE 1 | │ │ │ │ +
Definition at line 100 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define _UCOMMON_EXTENDED_ | │ │ │ │ +
Definition at line 62 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define _UCOMMON_PLATFORM_H_ | │ │ │ │ +
Definition at line 55 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define crit | │ │ │ │ +( | │ │ │ │ +│ │ │ │ + | x, | │ │ │ │ +
| │ │ │ │ + | │ │ │ │ + | │ │ │ │ + | text | │ │ │ │ +
| │ │ │ │ + | ) | │ │ │ │ +if(!(x)) cpr_runtime_error(text) | │ │ │ │ +
Definition at line 556 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define END_NAMESPACE } | │ │ │ │ +
Definition at line 92 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define INVALID_HANDLE_VALUE -1 | │ │ │ │ +
Definition at line 432 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define INVALID_SOCKET -1 | │ │ │ │ +
Definition at line 431 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define NAMESPACE_UCOMMON namespace ucommon { | │ │ │ │ +
Definition at line 91 of file platform.h.
│ │ │ │ │ │ │ │ -Definition in file protocols.h.
│ │ │ │ -| #define NDEBUG | │ │ │ │ +
Definition at line 221 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define PROGRAM_EXIT | │ │ │ │ +( | │ │ │ │ +│ │ │ │ + | code | ) | │ │ │ │ +return code | │ │ │ │ +
Definition at line 543 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define PROGRAM_MAIN | │ │ │ │ +( | │ │ │ │ +│ │ │ │ + | argc, | │ │ │ │ +
| │ │ │ │ + | │ │ │ │ + | │ │ │ │ + | argv | │ │ │ │ +
| │ │ │ │ + | ) | │ │ │ │ +extern "C" int main(int argc, char **argv) | │ │ │ │ +
Definition at line 542 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define SERVICE_MAIN | │ │ │ │ +( | │ │ │ │ +│ │ │ │ + | id, | │ │ │ │ +
| │ │ │ │ + | │ │ │ │ + | │ │ │ │ + | argc, | │ │ │ │ +
| │ │ │ │ + | │ │ │ │ + | │ │ │ │ + | argv | │ │ │ │ +
| │ │ │ │ + | ) | │ │ │ │ +void service_##id(int argc, char **argv) | │ │ │ │ +
Definition at line 548 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define UCOMMON_ABI 7 | │ │ │ │ +
Definition at line 56 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define UCOMMON_NAMESPACE ucommon | │ │ │ │ +
Definition at line 90 of file platform.h.
│ │ │ │ + │ │ │ │ +| #define UCOMMON_RTTI 1 | │ │ │ │ +
Definition at line 109 of file platform.h.
│ │ │ │ + │ │ │ │ +| typedef void(* cpr_service_t) (int argc, char **argv) | │ │ │ │ +
Definition at line 549 of file platform.h.
│ │ │ │ + │ │ │ │ +| typedef int fd_t | │ │ │ │ +
Definition at line 430 of file platform.h.
│ │ │ │ + │ │ │ │ +| typedef long Integer | │ │ │ │ +
Definition at line 569 of file platform.h.
│ │ │ │ + │ │ │ │ +| typedef double Real | │ │ │ │ +
Definition at line 571 of file platform.h.
│ │ │ │ + │ │ │ │ +| typedef void(* sighandler_t) (int) | │ │ │ │ +
Convenient typedef for signal handlers.
│ │ │ │ + │ │ │ │ +Definition at line 466 of file platform.h.
│ │ │ │ + │ │ │ │ +| typedef int socket_t | │ │ │ │ +
Definition at line 429 of file platform.h.
│ │ │ │ + │ │ │ │ +| typedef size_t socksize_t | │ │ │ │ +
Definition at line 311 of file platform.h.
│ │ │ │ + │ │ │ │ +| typedef size_t stacksize_t | │ │ │ │ +
Definition at line 428 of file platform.h.
│ │ │ │ + │ │ │ │ +| typedef unsigned long timeout_t | │ │ │ │ +
Definition at line 468 of file platform.h.
│ │ │ │ + │ │ │ │ +| typedef uint8_t ubyte_t | │ │ │ │ +
Definition at line 572 of file platform.h.
│ │ │ │ + │ │ │ │ +| typedef unsigned long Unsigned | │ │ │ │ +
Definition at line 570 of file platform.h.
│ │ │ │ + │ │ │ │ +
│ │ │ │ +
|
│ │ │ │ + │ │ │ │ +inline | │ │ │ │ +
Definition at line 631 of file platform.h.
│ │ │ │ + │ │ │ │ +
│ │ │ │ +
|
│ │ │ │ + │ │ │ │ +inline | │ │ │ │ +
Template function to initialize memory by invoking default constructor.
│ │ │ │ +If NULL is passed, then NULL is returned without any constructor called.
| memory | to initialize. |
Definition at line 566 of file platform.h.
│ │ │ │ + │ │ │ │ +
│ │ │ │ +
|
│ │ │ │ + │ │ │ │ +inline | │ │ │ │ +
Definition at line 596 of file platform.h.
│ │ │ │ + │ │ │ │ +
│ │ │ │ +
|
│ │ │ │ + │ │ │ │ +inline | │ │ │ │ +
Definition at line 608 of file platform.h.
│ │ │ │ + │ │ │ │ +
│ │ │ │ +
|
│ │ │ │ + │ │ │ │ +inline | │ │ │ │ +
Definition at line 582 of file platform.h.
│ │ │ │ + │ │ │ │ +
│ │ │ │ +
|
│ │ │ │ + │ │ │ │ +inline | │ │ │ │ +
Definition at line 618 of file platform.h.
│ │ │ │ + │ │ │ │ +
│ │ │ │ +
|
│ │ │ │ + │ │ │ │ +inline | │ │ │ │ +
Definition at line 602 of file platform.h.
│ │ │ │ + │ │ │ │ +| T protocol_cast | │ │ │ │ +( | │ │ │ │ +S * | │ │ │ │ +s | ) | │ │ │ │ +│ │ │ │ + |
Definition at line 129 of file platform.h.
│ │ │ │ + │ │ │ │ +
│ │ │ │ +
|
│ │ │ │ + │ │ │ │ +inline | │ │ │ │ +
Definition at line 625 of file platform.h.
│ │ │ │ + │ │ │ │ +
│ │ │ │ +
|
│ │ │ │ + │ │ │ │ +inline | │ │ │ │ +
Matching function for strdup().
│ │ │ │ +| string | to release from allocated memory. |
Definition at line 578 of file platform.h.
│ │ │ │ + │ │ │ │ + 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,39 +3,432 @@
│ │ │ │ │ * _N_a_m_e_s_p_a_c_e_s
│ │ │ │ │ * _D_a_t_a_ _S_t_r_u_c_t_u_r_e_s
│ │ │ │ │ * _F_i_l_e_s
│ │ │ │ │ * _E_x_a_m_p_l_e_s
│ │ │ │ │ * _F_i_l_e_ _L_i_s_t
│ │ │ │ │ * _G_l_o_b_a_l_s
│ │ │ │ │ * _u_c_o_m_m_o_n
│ │ │ │ │ -_N_a_m_e_s_p_a_c_e_s | _F_u_n_c_t_i_o_n_s
│ │ │ │ │ -protocols.h File Reference
│ │ │ │ │ -Abstract interfaces and support. _M_o_r_e_._._.
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_c_p_r_._h>
│ │ │ │ │ -Include dependency graph for protocols.h:
│ │ │ │ │ +_N_a_m_e_s_p_a_c_e_s | _M_a_c_r_o_s | _T_y_p_e_d_e_f_s | _F_u_n_c_t_i_o_n_s | _V_a_r_i_a_b_l_e_s
│ │ │ │ │ +platform.h File Reference
│ │ │ │ │ +Various miscellaneous platform specific headers and defines. _M_o_r_e_._._.
│ │ │ │ │ +#include 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,15 +3,15 @@
│ │ │ │ │ * _N_a_m_e_s_p_a_c_e_s
│ │ │ │ │ * _D_a_t_a_ _S_t_r_u_c_t_u_r_e_s
│ │ │ │ │ * _F_i_l_e_s
│ │ │ │ │ * _E_x_a_m_p_l_e_s
│ │ │ │ │ * _F_i_l_e_ _L_i_s_t
│ │ │ │ │ * _G_l_o_b_a_l_s
│ │ │ │ │ * _u_c_o_m_m_o_n
│ │ │ │ │ -protocols.h
│ │ │ │ │ +platform.h
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _d_o_c_u_m_e_n_t_a_t_i_o_n_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ 1// Copyright (C) 2006-2014 David Sugar, Tycho Softworks.
│ │ │ │ │ 2// Copyright (C) 2015-2020 Cherokees of Idaho.
│ │ │ │ │ 3//
│ │ │ │ │ 4// This file is part of GNU uCommon C++.
│ │ │ │ │ 5//
│ │ │ │ │ 6// GNU uCommon C++ is free software: you can redistribute it and/or modify
│ │ │ │ │ @@ -23,133 +23,618 @@
│ │ │ │ │ 12// but WITHOUT ANY WARRANTY; without even the implied warranty of
│ │ │ │ │ 13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
│ │ │ │ │ 14// GNU Lesser General Public License for more details.
│ │ │ │ │ 15//
│ │ │ │ │ 16// You should have received a copy of the GNU Lesser General Public License
│ │ │ │ │ 17// along with GNU uCommon C++. If not, see .
.
..
..
.Any ucommon streaming classes that are built from std::streamio facilities and that support ANSI C++ stream operators. │ │ │ │ +
Abstract interfaces and support. │ │ │ │ More...
│ │ │ │ -#include <ucommon/platform.h>#include <ucommon/protocols.h>#include <ucommon/thread.h>#include <ucommon/socket.h>#include <ucommon/fsys.h>#include <ucommon/shell.h>#include <iostream>#include <fstream>#include <ucommon/cpr.h>Go to the source code of this file.
│ │ │ ││ │ │ │ Namespaces | |
| namespace | ucommon |
│ │ │ │ Functions | |
| class | ucommon::__attribute__ ((visibility("default"))) ExclusiveProtocol |
| An exclusive locking protocol interface base. | |
| │ │ │ │ - | std::__attribute__ ((visibility("default"))) iostream &null |
| std::string & | ucommon::operator+ (std::string &target, String &source) |
| std::string & | ucommon::operator+= (std::string &target, String &source) |
| std::ostream & | ucommon::operator<< (std::ostream &os, Socket::address &addr) |
| std::ostream & | ucommon::operator<< (std::ostream &out, const PrintProtocol &format) |
| std::ostream & | ucommon::operator<< (std::ostream &out, const string_t &str) |
| std::ostream & | ucommon::operator<< (std::ostream &out, const stringlist_t &list) |
| std::istream & | ucommon::operator>> (std::istream &in, stringlist_t &list) |
| std::istream & | ucommon::operator>> (std::istream &inp, InputProtocol &format) |
| std::istream & | ucommon::operator>> (std::istream &inp, string_t &str) |
Any ucommon streaming classes that are built from std::streamio facilities and that support ANSI C++ stream operators.
│ │ │ │ +Abstract interfaces and support.
│ │ │ │ +This is a set of "protocols", a concept borrowed from other object oriented languages, to define interfaces for low level services. By using a protocol base class which offers both virtuals and support methods only, one can easily stack and share these as common base classes without having to consider when the final derived object implements them. Core protocol methods always are tagged with a _ prefix to make it easier to track their derivation.
│ │ │ │ + │ │ │ │ │ │ │ │ -Definition in file stream.h.
│ │ │ │ +Definition in file protocols.h.
│ │ │ │ 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -4,62 +4,38 @@
│ │ │ │ │ * _D_a_t_a_ _S_t_r_u_c_t_u_r_e_s
│ │ │ │ │ * _F_i_l_e_s
│ │ │ │ │ * _E_x_a_m_p_l_e_s
│ │ │ │ │ * _F_i_l_e_ _L_i_s_t
│ │ │ │ │ * _G_l_o_b_a_l_s
│ │ │ │ │ * _u_c_o_m_m_o_n
│ │ │ │ │ _N_a_m_e_s_p_a_c_e_s | _F_u_n_c_t_i_o_n_s
│ │ │ │ │ -stream.h File Reference
│ │ │ │ │ -Any ucommon streaming classes that are built from std::streamio facilities and
│ │ │ │ │ -that support ANSI C++ stream operators. _M_o_r_e_._._.
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_p_l_a_t_f_o_r_m_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_p_r_o_t_o_c_o_l_s_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_t_h_r_e_a_d_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_s_o_c_k_e_t_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_f_s_y_s_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_s_h_e_l_l_._h>
│ │ │ │ │ -#include 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,15 +3,15 @@
│ │ │ │ │ * _N_a_m_e_s_p_a_c_e_s
│ │ │ │ │ * _D_a_t_a_ _S_t_r_u_c_t_u_r_e_s
│ │ │ │ │ * _F_i_l_e_s
│ │ │ │ │ * _E_x_a_m_p_l_e_s
│ │ │ │ │ * _F_i_l_e_ _L_i_s_t
│ │ │ │ │ * _G_l_o_b_a_l_s
│ │ │ │ │ * _u_c_o_m_m_o_n
│ │ │ │ │ -stream.h
│ │ │ │ │ +protocols.h
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _d_o_c_u_m_e_n_t_a_t_i_o_n_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ 1// Copyright (C) 2006-2014 David Sugar, Tycho Softworks.
│ │ │ │ │ 2// Copyright (C) 2015-2020 Cherokees of Idaho.
│ │ │ │ │ 3//
│ │ │ │ │ 4// This file is part of GNU uCommon C++.
│ │ │ │ │ 5//
│ │ │ │ │ 6// GNU uCommon C++ is free software: you can redistribute it and/or modify
│ │ │ │ │ @@ -23,408 +23,133 @@
│ │ │ │ │ 12// but WITHOUT ANY WARRANTY; without even the implied warranty of
│ │ │ │ │ 13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
│ │ │ │ │ 14// GNU Lesser General Public License for more details.
│ │ │ │ │ 15//
│ │ │ │ │ 16// You should have received a copy of the GNU Lesser General Public License
│ │ │ │ │ 17// along with GNU uCommon C++. If not, see .
.
.
.
..
.Basic array and reusable object factory heap support. │ │ │ │ +
Common thread shared data types we will use. │ │ │ │ More...
│ │ │ │ -#include <ucommon/thread.h>#include <ucommon/cpr.h>#include <ucommon/atomic.h>#include <ucommon/protocols.h>#include <ucommon/object.h>#include <ucommon/typeref.h>#include <ucommon/thread.h>#include <ucommon/socket.h>Go to the source code of this file.
│ │ │ ││ │ │ │ -Data Structures | |
| class | ucommon::array_reuse< T > |
| An array of reusable objects. More... | |
| class | ucommon::paged_reuse< T > |
| A reusable private pool of reusable types. More... | |
│ │ │ │ Namespaces | |
| namespace | ucommon |
| Common namespace for all ucommon objects. | |
│ │ │ │ -Typedefs | |
| typedef unsigned short | ucommon::vectorsize_t |
│ │ │ │ +Functions | |
| class | ucommon::__attribute__ ((visibility("default"))) ExclusiveProtocol |
| An exclusive locking protocol interface base. | |
| template<typename T > | |
| bool | ucommon::mapped_keyequal (const T *key1, const T *key2) |
| template<> | |
| bool | ucommon::mapped_keyequal< char > (const char *k1, const char *k2) |
| template<> | |
| bool | ucommon::mapped_keyequal< struct sockaddr > (const struct sockaddr *s1, const struct sockaddr *s2) |
| template<typename T > | |
| size_t | ucommon::mapped_keypath (const T *addr) |
| template<> | |
| size_t | ucommon::mapped_keypath< char > (const char *addr) |
| template<> | |
| size_t | ucommon::mapped_keypath< struct sockaddr > (const struct sockaddr *addr) |
Basic array and reusable object factory heap support.
│ │ │ │ -This offers ucommon support for forming reusable object pools. Reusable object pools can be tied to local heaps and offer a means to create type factories that do not require global locking through malloc.
│ │ │ │ + 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,40 +3,58 @@
│ │ │ │ │ * _N_a_m_e_s_p_a_c_e_s
│ │ │ │ │ * _D_a_t_a_ _S_t_r_u_c_t_u_r_e_s
│ │ │ │ │ * _F_i_l_e_s
│ │ │ │ │ * _E_x_a_m_p_l_e_s
│ │ │ │ │ * _F_i_l_e_ _L_i_s_t
│ │ │ │ │ * _G_l_o_b_a_l_s
│ │ │ │ │ * _u_c_o_m_m_o_n
│ │ │ │ │ -_D_a_t_a_ _S_t_r_u_c_t_u_r_e_s | _N_a_m_e_s_p_a_c_e_s | _T_y_p_e_d_e_f_s
│ │ │ │ │ -reuse.h File Reference
│ │ │ │ │ -Basic array and reusable object factory heap support. _M_o_r_e_._._.
│ │ │ │ │ +_N_a_m_e_s_p_a_c_e_s | _F_u_n_c_t_i_o_n_s
│ │ │ │ │ +shared.h File Reference
│ │ │ │ │ +Common thread shared data types we will use. _M_o_r_e_._._.
│ │ │ │ │ +#include <_u_c_o_m_m_o_n_/_c_p_r_._h>
│ │ │ │ │ +#include <_u_c_o_m_m_o_n_/_a_t_o_m_i_c_._h>
│ │ │ │ │ +#include <_u_c_o_m_m_o_n_/_p_r_o_t_o_c_o_l_s_._h>
│ │ │ │ │ +#include <_u_c_o_m_m_o_n_/_o_b_j_e_c_t_._h>
│ │ │ │ │ +#include <_u_c_o_m_m_o_n_/_t_y_p_e_r_e_f_._h>
│ │ │ │ │ #include <_u_c_o_m_m_o_n_/_t_h_r_e_a_d_._h>
│ │ │ │ │ -Include dependency graph for reuse.h:
│ │ │ │ │ +#include <_u_c_o_m_m_o_n_/_s_o_c_k_e_t_._h>
│ │ │ │ │ +Include dependency graph for shared.h:
│ │ │ │ │ TThhiiss bbrroowwsseerr iiss nnoott aabbllee ttoo sshhooww SSVVGG:: ttrryy FFiirreeffooxx,, CChhrroommee,, SSaaffaarrii,, oorr OOppeerraa
│ │ │ │ │ iinnsstteeaadd..
│ │ │ │ │ This graph shows which files directly or indirectly include this file:
│ │ │ │ │ TThhiiss bbrroowwsseerr iiss nnoott aabbllee ttoo sshhooww SSVVGG:: ttrryy FFiirreeffooxx,, CChhrroommee,, SSaaffaarrii,, oorr OOppeerraa
│ │ │ │ │ iinnsstteeaadd..
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _s_o_u_r_c_e_ _c_o_d_e_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ -DDaattaa SSttrruuccttuurreess
│ │ │ │ │ -class _u_c_o_m_m_o_n_:_:_a_r_r_a_y___r_e_u_s_e_<_ _T_ _>
│ │ │ │ │ - An array of reusable objects. _M_o_r_e_._._.
│ │ │ │ │ -
│ │ │ │ │ -class _u_c_o_m_m_o_n_:_:_p_a_g_e_d___r_e_u_s_e_<_ _T_ _>
│ │ │ │ │ - A reusable private pool of reusable types. _M_o_r_e_._._.
│ │ │ │ │ -
│ │ │ │ │ NNaammeessppaacceess
│ │ │ │ │ namespace _u_c_o_m_m_o_n
│ │ │ │ │ Common namespace for all ucommon objects.
│ │ │ │ │
│ │ │ │ │ -TTyyppeeddeeffss
│ │ │ │ │ -typedef unsigned short _u_c_o_m_m_o_n_:_:_v_e_c_t_o_r_s_i_z_e___t
│ │ │ │ │ +FFuunnccttiioonnss
│ │ │ │ │ + class _u_c_o_m_m_o_n_:_:_____a_t_t_r_i_b_u_t_e____ ((visibility("default"))) ExclusiveProtocol
│ │ │ │ │ + An exclusive locking protocol interface base.
│ │ │ │ │ +
│ │ │ │ │ +template 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,285 +3,302 @@
│ │ │ │ │ * _N_a_m_e_s_p_a_c_e_s
│ │ │ │ │ * _D_a_t_a_ _S_t_r_u_c_t_u_r_e_s
│ │ │ │ │ * _F_i_l_e_s
│ │ │ │ │ * _E_x_a_m_p_l_e_s
│ │ │ │ │ * _F_i_l_e_ _L_i_s_t
│ │ │ │ │ * _G_l_o_b_a_l_s
│ │ │ │ │ * _u_c_o_m_m_o_n
│ │ │ │ │ -reuse.h
│ │ │ │ │ +shared.h
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _d_o_c_u_m_e_n_t_a_t_i_o_n_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ -1// Copyright (C) 2006-2014 David Sugar, Tycho Softworks.
│ │ │ │ │ -2// Copyright (C) 2015-2020 Cherokees of Idaho.
│ │ │ │ │ -3//
│ │ │ │ │ -4// This file is part of GNU uCommon C++.
│ │ │ │ │ -5//
│ │ │ │ │ -6// GNU uCommon C++ is free software: you can redistribute it and/or modify
│ │ │ │ │ -7// it under the terms of the GNU Lesser General Public License as published
│ │ │ │ │ -8// by the Free Software Foundation, either version 3 of the License, or
│ │ │ │ │ -9// (at your option) any later version.
│ │ │ │ │ -10//
│ │ │ │ │ -11// GNU uCommon C++ is distributed in the hope that it will be useful,
│ │ │ │ │ -12// but WITHOUT ANY WARRANTY; without even the implied warranty of
│ │ │ │ │ -13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
│ │ │ │ │ -14// GNU Lesser General Public License for more details.
│ │ │ │ │ -15//
│ │ │ │ │ -16// You should have received a copy of the GNU Lesser General Public License
│ │ │ │ │ -17// along with GNU uCommon C++. If not, see .
.
..
.Condition classes for thread sychronization and timing. │ │ │ │ +
Atomic pointers and locks. │ │ │ │ More...
│ │ │ │ -#include <ucommon/cpr.h>#include <ucommon/timers.h>#include <ucommon/memory.h>#include <ucommon/platform.h>Go to the source code of this file.
│ │ │ ││ │ │ │ Namespaces | |
| namespace | ucommon |
| Common namespace for all ucommon objects. | |
│ │ │ │ Typedefs | |
| typedef ConditionalAccess | ucommon::accesslock_t |
| Convenience type for scheduling access. | |
| typedef Barrier | ucommon::barrier_t |
| Convenience type for using thread barriers. | |
| typedef Semaphore | ucommon::semaphore_t |
| Convenience type for using counting semaphores. | |
| typedef int | atomic_t |
│ │ │ │ Functions | |
| class | ucommon::__attribute__ ((visibility("default"))) ExclusiveProtocol |
| An exclusive locking protocol interface base. | |
│ │ │ │ -Variables | |
| class __attribute__((visibility("default"))) Conditional class __attribute__((visibility("default"))) ConditionalAccess class __attribute__((visibility("default"))) ConditionalLock class __attribute__((visibility("default"))) Barrier class __attribute__((visibility("default"))) Semaphore typedef ConditionalLock | ucommon::condlock_t |
| The conditional is a common base for other thread synchronizing classes. | |
Condition classes for thread sychronization and timing.
│ │ │ │ -The theory behind ucommon sychronization objects is that all upper level sychronization objects can be formed directly from a mutex and conditional. This includes semaphores, barriers, rwlock, our own specialized conditional lock, resource-bound locking, and recursive exclusive locks. Using only conditionals means we are not dependent on platform specific pthread implementations that may not implement some of these, and hence improves portability and consistency. Given that our rwlocks are recursive access locks, one can safely create read/write threading pairs where the read threads need not worry about deadlocks and the writers need not either if they only write-lock one instance at a time to change state.
│ │ │ │ +Atomic pointers and locks.
│ │ │ │ +These are meant to use atomic CPU operations and hence offer maximum performance.
│ │ │ │ + │ │ │ │ + │ │ │ │ +Definition in file atomic.h.
│ │ │ │ +| typedef int atomic_t | │ │ │ │ +
Definition in file condition.h.
│ │ │ │ - 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,66 +3,42 @@
│ │ │ │ │ * _N_a_m_e_s_p_a_c_e_s
│ │ │ │ │ * _D_a_t_a_ _S_t_r_u_c_t_u_r_e_s
│ │ │ │ │ * _F_i_l_e_s
│ │ │ │ │ * _E_x_a_m_p_l_e_s
│ │ │ │ │ * _F_i_l_e_ _L_i_s_t
│ │ │ │ │ * _G_l_o_b_a_l_s
│ │ │ │ │ * _u_c_o_m_m_o_n
│ │ │ │ │ -_N_a_m_e_s_p_a_c_e_s | _T_y_p_e_d_e_f_s | _F_u_n_c_t_i_o_n_s | _V_a_r_i_a_b_l_e_s
│ │ │ │ │ -condition.h File Reference
│ │ │ │ │ -Condition classes for thread sychronization and timing. _M_o_r_e_._._.
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_c_p_r_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_t_i_m_e_r_s_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_m_e_m_o_r_y_._h>
│ │ │ │ │ -Include dependency graph for condition.h:
│ │ │ │ │ +_N_a_m_e_s_p_a_c_e_s | _T_y_p_e_d_e_f_s | _F_u_n_c_t_i_o_n_s
│ │ │ │ │ +atomic.h File Reference
│ │ │ │ │ +Atomic pointers and locks. _M_o_r_e_._._.
│ │ │ │ │ +#include <_u_c_o_m_m_o_n_/_p_l_a_t_f_o_r_m_._h>
│ │ │ │ │ +Include dependency graph for atomic.h:
│ │ │ │ │ TThhiiss bbrroowwsseerr iiss nnoott aabbllee ttoo sshhooww SSVVGG:: ttrryy FFiirreeffooxx,, CChhrroommee,, SSaaffaarrii,, oorr OOppeerraa
│ │ │ │ │ iinnsstteeaadd..
│ │ │ │ │ This graph shows which files directly or indirectly include this file:
│ │ │ │ │ TThhiiss bbrroowwsseerr iiss nnoott aabbllee ttoo sshhooww SSVVGG:: ttrryy FFiirreeffooxx,, CChhrroommee,, SSaaffaarrii,, oorr OOppeerraa
│ │ │ │ │ iinnsstteeaadd..
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _s_o_u_r_c_e_ _c_o_d_e_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ NNaammeessppaacceess
│ │ │ │ │ namespace _u_c_o_m_m_o_n
│ │ │ │ │ Common namespace for all ucommon objects.
│ │ │ │ │
│ │ │ │ │ TTyyppeeddeeffss
│ │ │ │ │ -typedef ConditionalAccess _u_c_o_m_m_o_n_:_:_a_c_c_e_s_s_l_o_c_k___t
│ │ │ │ │ - Convenience type for scheduling access.
│ │ │ │ │ -
│ │ │ │ │ - typedef Barrier _u_c_o_m_m_o_n_:_:_b_a_r_r_i_e_r___t
│ │ │ │ │ - Convenience type for using thread barriers.
│ │ │ │ │ -
│ │ │ │ │ - typedef Semaphore _u_c_o_m_m_o_n_:_:_s_e_m_a_p_h_o_r_e___t
│ │ │ │ │ - Convenience type for using counting semaphores.
│ │ │ │ │ +typedef int _a_t_o_m_i_c___t
│ │ │ │ │
│ │ │ │ │ FFuunnccttiioonnss
│ │ │ │ │ class _u_c_o_m_m_o_n_:_:_____a_t_t_r_i_b_u_t_e____ ((visibility("default"))) ExclusiveProtocol
│ │ │ │ │ An exclusive locking protocol interface base.
│ │ │ │ │
│ │ │ │ │ -VVaarriiaabblleess
│ │ │ │ │ - class _____a_t_t_r_i_b_u_t_e____((visibility
│ │ │ │ │ - ("default"))) Conditional class
│ │ │ │ │ - _____a_t_t_r_i_b_u_t_e____((visibility("default")))
│ │ │ │ │ - ConditionalAccess class _____a_t_t_r_i_b_u_t_e____(
│ │ │ │ │ - (visibility("default"))) ConditionalLock
│ │ │ │ │ - class _____a_t_t_r_i_b_u_t_e____((visibility
│ │ │ │ │ -("default"))) Barrier class _____a_t_t_r_i_b_u_t_e____
│ │ │ │ │ - ((visibility("default"))) Semaphore
│ │ │ │ │ - typedef ConditionalLock _u_c_o_m_m_o_n_:_:_c_o_n_d_l_o_c_k___t
│ │ │ │ │ - The conditional is a common base for
│ │ │ │ │ - other thread synchronizing classes.
│ │ │ │ │ -
│ │ │ │ │ ********** DDeettaaiilleedd DDeessccrriippttiioonn **********
│ │ │ │ │ -Condition classes for thread sychronization and timing.
│ │ │ │ │ -The theory behind ucommon sychronization objects is that all upper level
│ │ │ │ │ -sychronization objects can be formed directly from a mutex and conditional.
│ │ │ │ │ -This includes semaphores, barriers, rwlock, our own specialized conditional
│ │ │ │ │ -lock, resource-bound locking, and recursive exclusive locks. Using only
│ │ │ │ │ -conditionals means we are not dependent on platform specific pthread
│ │ │ │ │ -implementations that may not implement some of these, and hence improves
│ │ │ │ │ -portability and consistency. Given that our rwlocks are recursive access locks,
│ │ │ │ │ -one can safely create read/write threading pairs where the read threads need
│ │ │ │ │ -not worry about deadlocks and the writers need not either if they only write-
│ │ │ │ │ -lock one instance at a time to change state.
│ │ │ │ │ -Definition in file _c_o_n_d_i_t_i_o_n_._h.
│ │ │ │ │ +Atomic pointers and locks.
│ │ │ │ │ +These are meant to use atomic CPU operations and hence offer maximum
│ │ │ │ │ +performance.
│ │ │ │ │ + Author
│ │ │ │ │ + David Sugar _d_y_f_e_t_._n_o_s_p_@_m_._@_g_n_u_._n_o_s_p_@_m_._t_e_l_e_p_._n_o_s_p_@_m_._h_o_n_y_._n_o_s_p_@_m_._._o_r_g
│ │ │ │ │ +Definition in file _a_t_o_m_i_c_._h.
│ │ │ │ │ +********** TTyyppeeddeeff DDooccuummeennttaattiioonn **********
│ │ │ │ │ +********** _?◆_? aattoommiicc__tt **********
│ │ │ │ │ +typedef int atomic_t
│ │ │ │ │ +Definition at line _3_6 of file _a_t_o_m_i_c_._h.
│ │ │ │ │ ===============================================================================
│ │ │ │ │ Generated by _[_d_o_x_y_g_e_n_] 1.9.8
│ │ │ ├── ./usr/share/doc/ucommon-doc/html/a00440_source.html
│ │ │ │ @@ -1,15 +1,15 @@
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ - 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,15 +3,15 @@
│ │ │ │ │ * _N_a_m_e_s_p_a_c_e_s
│ │ │ │ │ * _D_a_t_a_ _S_t_r_u_c_t_u_r_e_s
│ │ │ │ │ * _F_i_l_e_s
│ │ │ │ │ * _E_x_a_m_p_l_e_s
│ │ │ │ │ * _F_i_l_e_ _L_i_s_t
│ │ │ │ │ * _G_l_o_b_a_l_s
│ │ │ │ │ * _u_c_o_m_m_o_n
│ │ │ │ │ -condition.h
│ │ │ │ │ +atomic.h
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _d_o_c_u_m_e_n_t_a_t_i_o_n_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ 1// Copyright (C) 2006-2014 David Sugar, Tycho Softworks.
│ │ │ │ │ 2// Copyright (C) 2015-2020 Cherokees of Idaho.
│ │ │ │ │ 3//
│ │ │ │ │ 4// This file is part of GNU uCommon C++.
│ │ │ │ │ 5//
│ │ │ │ │ 6// GNU uCommon C++ is free software: you can redistribute it and/or modify
│ │ │ │ │ @@ -23,452 +23,139 @@
│ │ │ │ │ 12// but WITHOUT ANY WARRANTY; without even the implied warranty of
│ │ │ │ │ 13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
│ │ │ │ │ 14// GNU Lesser General Public License for more details.
│ │ │ │ │ 15//
│ │ │ │ │ 16// You should have received a copy of the GNU Lesser General Public License
│ │ │ │ │ 17// along with GNU uCommon C++. If not, see .
.
.
..
..
.Basic classes for manipulating time and date based data, particularly that may be in strings. │ │ │ │ +
Placeholder for future classes that require stl support. │ │ │ │ More...
│ │ │ │ -#include <ucommon/platform.h>#include <ucommon/numbers.h>#include <ucommon/typeref.h>#include <unistd.h>#include <sys/time.h>#include <time.h>Go to the source code of this file.
│ │ │ ││ │ │ │ Namespaces | |
| namespace | ucommon |
| Common namespace for all ucommon objects. | |
│ │ │ │ -Macros | |
| #define | DATE_BUFFER_SIZE 11 |
| #define | DATE_STRING_SIZE 10 |
| #define | DATETIME_BUFFER_SIZE 20 |
| #define | DATETIME_STRING_SIZE 19 |
| #define | TIME_BUFFER_SIZE 9 |
| #define | TIME_STRING_SIZE 8 |
│ │ │ │ -Typedefs | |
| typedef Date | ucommon::date_t |
| Convenience type for using Date object. | |
| typedef DateTimeString | ucommon::datetimestring_t |
| Convenience type for using DateTimeString object. | |
| typedef struct tm | tm_t |
| Convenience type for struct tm. | |
| typedef Time | ucommon::tod_t |
| Convenience type for using Time object. | |
│ │ │ │ -Functions | |
| class | ucommon::__attribute__ ((visibility("default"))) ExclusiveProtocol |
| An exclusive locking protocol interface base. | |
│ │ │ │ -Variables | |
| class __attribute__((visibility("default"))) DateTime class __attribute__((visibility("default"))) DateTimeString class __attribute__((visibility("default"))) DateNumber class __attribute__((visibility("default"))) isotime typedef DateTime | ucommon::datetime_t |
| The Datetime class uses a julian date representation of the current year, month, and day and a integer representation of the current time. | |
Basic classes for manipulating time and date based data, particularly that may be in strings.
│ │ │ │ +Placeholder for future classes that require stl support.
│ │ │ │ │ │ │ │ -Definition in file datetime.h.
│ │ │ │ -| #define DATE_BUFFER_SIZE 11 | │ │ │ │ -
Definition at line 53 of file datetime.h.
│ │ │ │ - │ │ │ │ -| #define DATE_STRING_SIZE 10 | │ │ │ │ -
Definition at line 52 of file datetime.h.
│ │ │ │ - │ │ │ │ -| #define DATETIME_BUFFER_SIZE 20 | │ │ │ │ -
Definition at line 57 of file datetime.h.
│ │ │ │ - │ │ │ │ -| #define DATETIME_STRING_SIZE 19 | │ │ │ │ -
Definition at line 56 of file datetime.h.
│ │ │ │ - │ │ │ │ -| #define TIME_BUFFER_SIZE 9 | │ │ │ │ -
Definition at line 55 of file datetime.h.
│ │ │ │ - │ │ │ │ -| #define TIME_STRING_SIZE 8 | │ │ │ │ -
Definition at line 54 of file datetime.h.
│ │ │ │ - │ │ │ │ -| typedef struct tm tm_t | │ │ │ │ -
Convenience type for struct tm.
│ │ │ │ - │ │ │ │ -Definition at line 62 of file datetime.h.
│ │ │ │ - │ │ │ │ -Definition in file stl.h.
│ │ │ │ + 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,101 +3,28 @@
│ │ │ │ │ * _N_a_m_e_s_p_a_c_e_s
│ │ │ │ │ * _D_a_t_a_ _S_t_r_u_c_t_u_r_e_s
│ │ │ │ │ * _F_i_l_e_s
│ │ │ │ │ * _E_x_a_m_p_l_e_s
│ │ │ │ │ * _F_i_l_e_ _L_i_s_t
│ │ │ │ │ * _G_l_o_b_a_l_s
│ │ │ │ │ * _u_c_o_m_m_o_n
│ │ │ │ │ -_N_a_m_e_s_p_a_c_e_s | _M_a_c_r_o_s | _T_y_p_e_d_e_f_s | _F_u_n_c_t_i_o_n_s | _V_a_r_i_a_b_l_e_s
│ │ │ │ │ -datetime.h File Reference
│ │ │ │ │ -Basic classes for manipulating time and date based data, particularly that may
│ │ │ │ │ -be in strings. _M_o_r_e_._._.
│ │ │ │ │ +_N_a_m_e_s_p_a_c_e_s
│ │ │ │ │ +stl.h File Reference
│ │ │ │ │ +Placeholder for future classes that require stl support. _M_o_r_e_._._.
│ │ │ │ │ #include <_u_c_o_m_m_o_n_/_p_l_a_t_f_o_r_m_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_n_u_m_b_e_r_s_._h>
│ │ │ │ │ -#include <_u_c_o_m_m_o_n_/_t_y_p_e_r_e_f_._h>
│ │ │ │ │ -#include 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -3,15 +3,15 @@
│ │ │ │ │ * _N_a_m_e_s_p_a_c_e_s
│ │ │ │ │ * _D_a_t_a_ _S_t_r_u_c_t_u_r_e_s
│ │ │ │ │ * _F_i_l_e_s
│ │ │ │ │ * _E_x_a_m_p_l_e_s
│ │ │ │ │ * _F_i_l_e_ _L_i_s_t
│ │ │ │ │ * _G_l_o_b_a_l_s
│ │ │ │ │ * _u_c_o_m_m_o_n
│ │ │ │ │ -datetime.h
│ │ │ │ │ +stl.h
│ │ │ │ │ _G_o_ _t_o_ _t_h_e_ _d_o_c_u_m_e_n_t_a_t_i_o_n_ _o_f_ _t_h_i_s_ _f_i_l_e_.
│ │ │ │ │ 1// Copyright (C) 2006-2014 David Sugar, Tycho Softworks.
│ │ │ │ │ 2// Copyright (C) 2015-2020 Cherokees of Idaho.
│ │ │ │ │ 3//
│ │ │ │ │ 4// This file is part of GNU uCommon C++.
│ │ │ │ │ 5//
│ │ │ │ │ 6// GNU uCommon C++ is free software: you can redistribute it and/or modify
│ │ │ │ │ @@ -23,441 +23,36 @@
│ │ │ │ │ 12// but WITHOUT ANY WARRANTY; without even the implied warranty of
│ │ │ │ │ 13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
│ │ │ │ │ 14// GNU Lesser General Public License for more details.
│ │ │ │ │ 15//
│ │ │ │ │ 16// You should have received a copy of the GNU Lesser General Public License
│ │ │ │ │ 17// along with GNU uCommon C++. If not, see .
.
.Locking protocol classes for member function automatic operations. │ │ │ │ +
Basic UCommon Unicode support. │ │ │ │ More...
│ │ │ │ -#include <ucommon/platform.h>#include <ucommon/cpr.h>#include <ucommon/protocols.h>#include <ucommon/string.h>│ │ │ │ Namespaces | |
| namespace | ucommon |
| Common namespace for all ucommon objects. | |
│ │ │ │ -Macros | |
| #define | __EXCLUSIVE(x) exclusive_access __autolock__ = x |
| #define | __SHARE(x) shared_access __autolock__ = x |
| #define | _UCOMMON_ACCESS_H_ |
│ │ │ │ +Typedefs | |
| typedef int16_t | ucommon::ucs2_t |
| 16 bit unicode character code. | |
| typedef int32_t | ucommon::ucs4_t |
| 32 bit unicode character code. | |
| typedef void * | ucommon::unicode_t |
| Resolves issues where wchar_t is not defined. | |
| typedef UString | ucommon::ustring_t |
| Convenience type for utf8 encoded strings. | |
| typedef utf8_pointer | ucommon::utf8_t |
| Convenience type for utf8_pointer strings. | |
│ │ │ │ Functions | |
| class | ucommon::__attribute__ ((visibility("default"))) ExclusiveProtocol |
| An exclusive locking protocol interface base. | |
| template<> | |
| void | ucommon::dupfree< ucs2_t * > (ucs2_t *string) |
| template<> | |
| void | ucommon::dupfree< ucs4_t * > (ucs4_t *string) |
| template<> | |
| void | ucommon::dupfree< unicode_t > (unicode_t string) |
| ucs4_t * | ucommon::strudup (const char *string) |
| ucs2_t * | ucommon::strwdup (const char *string) |
Locking protocol classes for member function automatic operations.
│ │ │ │ -This header covers ucommon access related classes. These are used to provide automatic management of locks and synchronization objects through common virtual base classes which can be used with automatic objects. These classes are related to "protocols" and are used in conjunction with smart pointer/referencing classes. The access interface supports member functions to acquire a lock when entered and automatically release the lock when the member function returns that are used in conjunction with special referencing smart pointers.
│ │ │ │ +Basic UCommon Unicode support.
│ │ │ │ +This includes computing unicode transcoding and supporting a UTF8-aware string class (UString). We may add support for a wchar_t aware string class as well, as some external api libraries may require ucs-2 or 4 encoded strings.
│ │ │ │ │ │ │ │ -Definition in file access.h.
│ │ │ │ -| #define __EXCLUSIVE | │ │ │ │ -( | │ │ │ │ -│ │ │ │ - | x | ) | │ │ │ │ -exclusive_access __autolock__ = x | │ │ │ │ -
| #define __SHARE | │ │ │ │ -( | │ │ │ │ -│ │ │ │ - | x | ) | │ │ │ │ -shared_access __autolock__ = x | │ │ │ │ -
Definition in file unicode.h.
│ │ │ │ + 1.9.8
│ │ │ │
│ │ │ │
│ │ │ │