24 #ifndef _UCOMMON_SHARED_H_ 25 #define _UCOMMON_SHARED_H_ 27 #ifndef _UCOMMON_CPR_H_ 31 #ifndef _UCOMMON_ATOMIC_H_ 35 #ifndef _UCOMMON_PROTOCOLS_H_ 39 #ifndef _UCOMMON_OBJECT_H_ 43 #ifndef _UCOMMON_TYPEREF_H_ 47 #ifndef _UCOMMON_THREAD_H_ 51 #ifndef _UCOMMON_SOCKET_H_ 57 class __EXPORT SharedRef :
protected TypeRef
60 __DELETE_COPY(SharedRef);
69 void get(TypeRef&
object);
71 void put(TypeRef&
object);
75 class sharedref :
private SharedRef
78 __DELETE_COPY(sharedref);
81 inline sharedref() : SharedRef() {};
83 inline operator typeref<T>() {
90 inline typeref<T> operator*() {
97 inline void put(typeref<T>& ptr) {
101 inline sharedref& operator=(typeref<T> ptr) {
106 inline sharedref& operator=(T obj) {
113 class __EXPORT MappedPointer
116 __DELETE_COPY(MappedPointer);
119 class __EXPORT Index :
public LinkedObject
122 explicit Index(LinkedObject **origin);
130 LinkedObject *free, **list;
136 MappedPointer(
size_t indexes,
condlock_t *locking = NULL,
size_t paging = 0);
139 LinkedObject *access(
size_t path);
141 LinkedObject *modify(
size_t path);
143 void release(
void *obj);
145 void insert(
const void *key,
void *value,
size_t path);
147 void replace(Index *ind,
void *value);
149 void remove(Index *ind,
size_t path);
152 static size_t keypath(
const uint8_t *
addr,
size_t size);
156 inline size_t mapped_keypath(
const T *
addr)
161 return MappedPointer::keypath((
const uint8_t *)
addr,
sizeof(T));
165 inline bool mapped_keyequal(
const T* key1,
const T* key2)
169 return !memcmp(key1, key2,
sizeof(T));
173 inline size_t mapped_keypath<char>(
const char *
addr)
178 return MappedPointer::keypath((
const uint8_t *)
addr, strlen(
addr));
182 inline bool mapped_keyequal<char>(
const char *k1,
const char *k2)
191 inline size_t mapped_keypath<struct sockaddr>(
const struct sockaddr *
addr)
200 inline bool mapped_keyequal<struct sockaddr>(
const struct sockaddr *s1,
const struct sockaddr *s2)
207 template<
typename K,
typename V>
208 class mapped_pointer :
public MappedPointer
211 inline mapped_pointer(
size_t indexes = 37,
condlock_t *locking = NULL,
size_t paging = 0) : MappedPointer(indexes, locking, paging) {}
213 inline void release(V*
object) {
214 MappedPointer::release(
object);
217 void remove(
const K* key) {
218 size_t path = mapped_keypath<K>(key);
219 linked_pointer<Index> ip = modify(path);
221 if(mapped_keyequal<K>((
const K*)(ip->key), key)) {
222 MappedPointer::remove(*ip, path);
230 V* get(
const K* key) {
231 linked_pointer<Index> ip = access(mapped_keypath<K>(key));
233 if(mapped_keyequal<K>((
const K*)(ip->key), key)) {
234 return static_cast<V*>(ip->value);
242 void set(
const K* key, V* ptr) {
243 size_t path = mapped_keypath<K>(key);
244 linked_pointer<Index> ip = modify(path);
246 if(mapped_keyequal<K>((
const K*)(ip->key), key)) {
251 insert((
const void *)key, (
void *)ptr, path);
static void put(TypeRef &target, Counted *object)
Special weak-public means to copy a container reference.
bool eq(const struct sockaddr *s1, const struct sockaddr *s2)
Compare two socket addresses to see if equal.
A common object base class with auto-pointer support.
bool is(T &object)
Convenience function to validate object assuming it is castable to bool.
const struct sockaddr * addr(Socket::address &address)
A convenience function to convert a socket address list into a socket address.
Atomic pointers and locks.
Thread classes and sychronization objects.
ConditionalLock condlock_t
Convenience type for using conditional locks.
Common namespace for all ucommon objects.
Common socket class and address manipulation.
Abstract interfaces and support.
static bool equal(const struct sockaddr *address1, const struct sockaddr *address2)
Compare socket addresses.
A thread-safe atomic heap management system.
static socklen_t len(const struct sockaddr *address)
Get the size of a socket address.