ExternalVendorCode/genode
1
0
Fork 0
mirror of https://github.com/genodelabs/genode.git synced 2025-06-16 22:28:18 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

base: rename 'Volatile_object' to 'Reconstructible'

Browse Source 
Fixes #2151
This commit is contained in:
Norman Feske
2016-12-01 17:37:08 +01:00
parent 6fa87e62dd
commit 25a7ea3d40
76 changed files with 421 additions and 383 deletions
Download Patch File Download Diff File Expand all files Collapse all files

167
repos/base/include/util/volatile_object.h
View File

@ -2,6 +2,8 @@
* \brief Utility for manual in-place construction of objects
* \author Norman Feske
* \date 2014-01-10
*
* \deprecated use 'util/reconstructible.h' instead
*/
/*
@ -14,158 +16,23 @@
#ifndef _INCLUDE__UTIL__VOLATILE_OBJECT_H_
#define _INCLUDE__UTIL__VOLATILE_OBJECT_H_
#include <util/construct_at.h>
#include <base/stdint.h>
#include <util/noncopyable.h>
#include <util/reconstructible.h>
#warning "'util/volatile_object.h' is deprecated, use 'util/reconstructible.h' instead (see https://github.com/genodelabs/genode/issues/2151)"
namespace Genode {
template<typename> class Volatile_object;
template<typename> class Lazy_volatile_object;
template <typename T>
struct Volatile_object : Reconstructible<T>
{
using Reconstructible<T>::Reconstructible;
};
template <typename T>
struct Lazy_volatile_object : Constructible<T>
{
using Constructible<T>::Constructible;
};
}
/**
* Place holder for an object to be repeatedly constructed and destructed
*
* This class template acts as a smart pointer that refers to an object
* contained within the smart pointer itself. The contained object may be
* repeatedly constructed and destructed while staying in the same place. This
* is useful for replacing aggregated members during the lifetime of a compound
* object.
*
* \param MT type
*/
template <typename MT>
class Genode::Volatile_object : Noncopyable
{
private:
/**
* Static reservation of memory for the embedded object
*/
char _space[sizeof(MT)] __attribute__((aligned(sizeof(addr_t))));
/**
* True if the volatile object contains a constructed object
*/
bool _constructed = false;
template <typename... ARGS> void _do_construct(ARGS &&... args)
{
construct_at<MT>(_space, args...);
_constructed = true;
}
MT *_ptr() { return reinterpret_cast<MT *>(_space); }
MT const *_const_ptr() const { return reinterpret_cast<MT const *>(_space); }
void _check_constructed() const
{
if (!_constructed)
throw Deref_unconstructed_object();
}
protected:
/**
* Dummy type used as a hook for 'Lazy_volatile_object' to bypass the
* default constructor by invoking the 'Volatile_object(Lazy *)'
* constructor.
*/
struct Lazy { };
/**
* Constructor that omits the initial construction of the object
*/
Volatile_object(Lazy *) { }
public:
class Deref_unconstructed_object { };
/**
* Constructor
*
* The arguments are forwarded to the constructor of the embedded
* object.
*/
template <typename... ARGS>
Volatile_object(ARGS &&... args)
{
_do_construct(args...);
}
~Volatile_object() { destruct(); }
/**
* Construct new object in place
*
* If the 'Volatile_object' already hosts a constructed object, the old
* object will be destructed first.
*/
template <typename... ARGS>
void construct(ARGS &&... args)
{
destruct();
_do_construct(args...);
}
/**
* Destruct object
*/
void destruct()
{
if (!_constructed)
return;
/* invoke destructor */
_ptr()->~MT();
_constructed = false;
}
/**
* Return true of volatile object contains a constructed object
*/
bool constructed() const { return _constructed; }
/**
* Return true of volatile object contains a constructed object
*
* \deprecated use 'constructed' instead
*/
bool is_constructed() const { return constructed(); }
/**
* Access contained object
*/
MT *operator -> () { _check_constructed(); return _ptr(); }
MT const *operator -> () const { _check_constructed(); return _const_ptr(); }
MT &operator * () { _check_constructed(); return *_ptr(); }
MT const &operator * () const { _check_constructed(); return *_const_ptr(); }
void print(Output &out) const
{
if (_constructed)
_const_ptr()->print(out);
else
out.out_string("<unconstructed>");
}
};
/**
* Volatile object that holds no initially constructed object
*/
template <typename MT>
struct Genode::Lazy_volatile_object : Volatile_object<MT>
{
template <typename... ARGS>
Lazy_volatile_object(ARGS &&... args)
:
Volatile_object<MT>((typename Volatile_object<MT>::Lazy *)0)
{ }
};
#endif /* _INCLUDE__UTIL__VOLATILE_OBJECT_H_ */