Classes | |
struct | TcpAddress |
TCP address of a broker - host:port. More... | |
struct | Address |
Address is a variant of all address types, more coming in future. More... | |
class | DataDir |
DataDir class. More... | |
class | Exception |
Base class for Qpid runtime exceptions. More... | |
struct | ErrnoException |
Exception that includes an errno message. More... | |
class | InlineAllocator |
An allocator that has inline storage for up to Max objects of type BaseAllocator::value_type. More... | |
class | InlineVector |
A vector that stores up to Max elements in inline storage, otherwise uses normal vector allocation. More... | |
struct | Msg |
A simple wrapper for std::ostringstream that allows in place construction of a message and automatic conversion to string. More... | |
struct | Options |
Base class for options. More... | |
struct | CommonOptions |
Standard options for configuration. More... | |
class | Plugin |
Plug-in base class. More... | |
class | Range |
A range of values, used in RangeSet. More... | |
class | RangeSet |
A set implemented as a list of [begin, end) ranges. More... | |
class | RefCounted |
Reference-counted base class. More... | |
class | RefCountedBuffer |
Reference-counted byte buffer. More... | |
struct | SerializablePair |
Serialize std::pair. More... | |
class | Serializer |
Base class for all serializers. More... | |
class | EncoderBase |
Base class for encoders, provides generic encode functions. More... | |
class | DecoderBase |
Base class for decoders, provides generic decode functions. More... | |
struct | SerializeAs |
Serialize a type by converting it to/from another type. More... | |
class | SessionId |
Identifier for a session. More... | |
struct | SessionPoint |
A point in the session. More... | |
class | SessionState |
Support for session idempotence barrier and resume as defined in AMQP 0-10. More... | |
class | SharedObject |
Template to enforce shared object conventions. More... | |
struct | Url |
An AMQP URL contains a list of addresses. More... | |
Namespaces | |
namespace | framing |
The framing namespace contains classes that are used to create, send and receive the basic packets from which AMQP is built. | |
Typedefs | |
typedef boost::is_same < boost::ptr_map< int, int > ::iterator::value_type, int > | IsOldPtrMap |
Functions | |
bool | operator== (const TcpAddress &x, const TcpAddress &y) |
void | assert_fail (char const *expr, char const *function, char const *file, long line) |
template<class T> | |
std::auto_ptr< T > | make_auto_ptr (T *ptr) |
Convenient template for creating auto_ptr in-place in an argument list. | |
template<class T> | |
const Msg & | operator<< (const Msg &m, const T &t) |
std::ostream & | operator<< (std::ostream &o, const Msg &m) |
std::string | prettyArg (const std::string &, const std::string &) |
template<class T> | |
po::value_semantic * | optValue (T &value, const char *name) |
Create an option value. | |
template<class T> | |
po::value_semantic * | optValue (std::vector< T > &value, const char *name) |
Create a vector value. | |
po::value_semantic * | optValue (bool &value) |
Create a boolean switch value. | |
template<class Iter> | |
boost::enable_if< IsOldPtrMap, typename Iter::value_type * > ::type | ptr_map_ptr (const Iter &i) |
template<class T> | |
std::ostream & | operator<< (std::ostream &o, const Range< T > &r) |
template<class T> | |
std::ostream & | operator<< (std::ostream &o, const RangeSet< T > &rs) |
template<class T> | |
T & | serializable (T &t) |
Overload for types that do not provide a serialize() member. | |
template<class T, class U> | |
SerializablePair< T, U > | serializable (std::pair< T, U > &p) |
std::ostream & | operator<< (std::ostream &, const SessionId &) |
std::ostream & | operator<< (std::ostream &, const SessionPoint &) |
bool | operator== (const SessionId &id, const SessionState &s) |
template<class T> | |
shared_ptr< T > | make_shared_ptr (T *ptr) |
template<class T, class D> | |
shared_ptr< T > | make_shared_ptr (T *ptr, D deleter) |
void | nullDeleter (void const *) |
void | split (std::vector< std::string > &out, const std::string &in, const std::string &delims) |
Split 'in' into words using delimiters in 'delims' and put resulting strings into 'out' vector. | |
std::vector< std::string > | split (const std::string &in, const std::string &delims) |
Split 'in' into words using delimiters in 'delims' and return the resulting strings in a vector. | |
std::ostream & | operator<< (std::ostream &os, const TcpAddress &a) |
bool | operator== (const Url &a, const Url &b) |
bool | operator!= (const Url &a, const Url &b) |
std::ostream & | operator<< (std::ostream &os, const Url &url) |
std::istream & | operator>> (std::istream &is, Url &url) |
Variables | |
const std::string | product = "qpidc" |
const std::string | version = "0.3" |
const std::string | saslName = "qpid-broker" |
This file was automatically generated from the AMQP specification.
As such, an instance of this class will hold a list of operations representing the workload of the transaction. This work can be committed or rolled back. Committing is a two-stage process: first all the operations should be prepared, then if that succeeds they can be committed.
In the 2pc case, a successful prepare may be followed by either a commit or a rollback.
Atomicity of prepare is ensured by using a lower level transactional facility. This saves explicitly rolling back all the successfully prepared ops when one of them fails. i.e. we do not use 2pc internally, we instead ensure that prepare is atomic at a lower level. This makes individual prepare operations easier to code.
Transactions on a messaging broker effect three types of 'action': (1) updates to persistent storage (2) updates to transient storage or cached data (3) network writes.
Of these, (1) should always occur atomically during prepare to ensure that if the broker crashes while a transaction is being completed the persistent state (which is all that then remains) is consistent. (3) can only be done on commit, after a successful prepare. There is a little more flexibility with (2) but any changes made during prepare should be subject to the control of the TransactionalStore in use.
Do not edit.
std::auto_ptr<T> qpid::make_auto_ptr | ( | T * | ptr | ) | [inline] |
po::value_semantic* qpid::optValue | ( | bool & | value | ) | [inline] |
po::value_semantic* qpid::optValue | ( | std::vector< T > & | value, | |
const char * | name | |||
) | [inline] |
po::value_semantic* qpid::optValue | ( | T & | value, | |
const char * | name | |||
) | [inline] |
T& qpid::serializable | ( | T & | t | ) | [inline] |
Overload for types that do not provide a serialize() member.
It should retrun a wrapper holding a reference to t that implements serialize()
Definition at line 36 of file Serializer.h.
Referenced by qpid::DecoderBase< qpid::amqp_0_10::Codec::Decoder< InIter > >::operator()(), and qpid::EncoderBase< qpid::amqp_0_10::Codec::Size >::operator()().