Tracked.h File Reference

#include <string>
#include <vector>
#include <map>
#include <list>
#include <type_traits>
#include <initializer_list>
#include "madara/knowledge/KnowledgeRecord.h"
#include "madara/knowledge/Functions.h"
#include "madara/utility/StdInt.h"
#include "madara/MadaraExport.h"
#include "madara/knowledge/VariableReference.h"
#include "madara/knowledge/KnowledgeBase.h"
#include "madara/knowledge/KnowledgeCast.h"
#include "madara/knowledge/ContextGuard.h"

Go to the source code of this file.

Classes
class	madara::knowledge::rcw::Tracked< T >
	Tracks the modification status of a wrapped object of the given type. More...
class	madara::knowledge::rcw::Tracked< std::vector< T > >
	Implement functionality specific to std::vectors. More...
class	madara::knowledge::rcw::TrackedCollection< T, Impl >
	Used internally by Tracked. More...
class	madara::knowledge::rcw::TrackedCollection< T, Impl >
	Used internally by Tracked. More...
class	madara::knowledge::rcw::TrackedExtra< T, Impl >
	Provides default versions of methods below. More...
class	madara::knowledge::rcw::TrackedExtra< std::basic_string< Char >, Impl >
	Adds functionality specific to std::basic_string. More...

Namespaces
	madara
	Copyright (c) 2015 Carnegie Mellon University.
	madara::knowledge
	Provides functions and classes for the distributed knowledge base.
	madara::knowledge::rcw
	Namespace holding Read-Compute-Write based abstractions for knowledge base access.

Macros
#define	MADARA_AUTOTYPE_BODY(body)   -> decltype(body) { return (body); }
#define	MADARA_MAKE_BINARY_ARITH_OP(op)
#define	MADARA_MAKE_BINARY_COMPARE_OP(op)
#define	MADARA_MAKE_COMPOUND_OP(op)
#define	MADARA_MAKE_INCDEC_OP(op)
#define	MADARA_MAKE_UNARY_ARITH_OP(op)

Typedefs
typedef Tracked< bool >	madara::knowledge::rcw::TrackedBool
typedef Tracked< char >	madara::knowledge::rcw::TrackedChar
typedef Tracked< double >	madara::knowledge::rcw::TrackedDouble
typedef Tracked< std::vector< double > >	madara::knowledge::rcw::TrackedDoubleVector
typedef Tracked< float >	madara::knowledge::rcw::TrackedFloat
typedef Tracked< int16_t >	madara::knowledge::rcw::TrackedI16
typedef Tracked< int32_t >	madara::knowledge::rcw::TrackedI32
typedef Tracked< int64_t >	madara::knowledge::rcw::TrackedI64
typedef Tracked< int8_t >	madara::knowledge::rcw::TrackedI8
typedef Tracked< int >	madara::knowledge::rcw::TrackedInt
typedef Tracked< std::vector< int64_t > >	madara::knowledge::rcw::TrackedIntVector
typedef Tracked< long >	madara::knowledge::rcw::TrackedLong
typedef Tracked< long double >	madara::knowledge::rcw::TrackedLongDouble
typedef Tracked< long long >	madara::knowledge::rcw::TrackedLongLong
typedef Tracked< signed char >	madara::knowledge::rcw::TrackedSChar
typedef Tracked< short >	madara::knowledge::rcw::TrackedShort
typedef Tracked< std::string >	madara::knowledge::rcw::TrackedString
typedef Tracked< uint16_t >	madara::knowledge::rcw::TrackedU16
typedef Tracked< uint32_t >	madara::knowledge::rcw::TrackedU32
typedef Tracked< uint64_t >	madara::knowledge::rcw::TrackedU64
typedef Tracked< uint8_t >	madara::knowledge::rcw::TrackedU8
typedef Tracked< unsigned char >	madara::knowledge::rcw::TrackedUChar
typedef Tracked< unsigned int >	madara::knowledge::rcw::TrackedUInt
typedef Tracked< unsigned long >	madara::knowledge::rcw::TrackedULong
typedef Tracked< unsigned long long >	madara::knowledge::rcw::TrackedULongLong
typedef Tracked< unsigned short >	madara::knowledge::rcw::TrackedUShort

Functions
template<typename T >
void	madara::knowledge::rcw::clear_dirty (Tracked< T > &t)
	Clears dirty flag of Tracked types. More...
template<typename T >
void	madara::knowledge::rcw::clear_dirty (std::vector< Tracked< T >> &t, size_t i)
	Clears dirty flag of given index of vector of Tracked types. More...
template<typename T >
void	madara::knowledge::rcw::clear_dirty (Tracked< std::vector< T >> &t, size_t i)
	Clear dirty flag at index of Tracked vector. More...
template<typename T >
auto	madara::knowledge::rcw::get_value (const Tracked< T > &t) -> decltype(get_value(t.get()))
	Get value of Tracked type. More...
char	madara::knowledge::rcw::get_value (const Tracked< std::string > &t, size_t i)
	Get value of given index of Tracked string type. More...
template<typename T >
const T &	madara::knowledge::rcw::get_value (const Tracked< std::vector< T >> &t, size_t i)
	Get value at index of Tracked vector. More...
template<typename T >
bool	madara::knowledge::rcw::is_all_dirty (const Tracked< std::vector< T >> &t)
	Return global dirty flag of Tracked vector. More...
template<typename T >
bool	madara::knowledge::rcw::is_dirty (const Tracked< T > &t)
	Returns dirty flag of Tracked types. More...
template<typename T >
bool	madara::knowledge::rcw::is_dirty (const std::vector< Tracked< T >> &t, size_t i)
	Returns dirty flag of given index of vector of Tracked types. More...
template<typename T >
bool	madara::knowledge::rcw::is_dirty (const Tracked< std::vector< T >> &t, size_t i)
	Return dirty flag at index of Tracked vector. More...
template<typename T >
bool	madara::knowledge::rcw::is_size_dirty (const Tracked< std::vector< T >> &t)
	Return size changed dirty flag of Tracked vector. More...
template<class T >
auto	madara::knowledge::rcw::operator! (const Tracked< T > &lhs) -> decltype(!lhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator!= (const Tracked< T > &lhs, const Tracked< U > &rhs) -> decltype(lhs.get()!=rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator!= (const Tracked< T > &lhs, U &&rhs) -> decltype(lhs.get()!=std::forward< U >(rhs))
template<class T , class U >
auto	madara::knowledge::rcw::operator!= (T &&lhs, const Tracked< U > &rhs) -> decltype(std::forward< T >(lhs)!=rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator% (const Tracked< T > &lhs, U &&rhs) -> decltype(lhs.get()%std::forward< U >(rhs))
template<class T , class U >
auto	madara::knowledge::rcw::operator% (T &&lhs, const Tracked< U > &rhs) -> decltype(std::forward< T >(lhs)%rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator% (const Tracked< T > &lhs, const Tracked< U > &rhs) -> decltype(lhs.get()%rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator%= (Tracked< T > &lhs, U &&rhs) -> decltype(lhs.get_mut()%=std::forward< U >(rhs))
template<class T , class U >
auto	madara::knowledge::rcw::operator%= (Tracked< T > &lhs, const Tracked< U > &rhs) -> decltype(lhs.get_mut()%=rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator%= (T &lhs, const Tracked< U > &rhs) -> decltype(lhs%=rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator& (const Tracked< T > &lhs, const Tracked< U > &rhs) -> decltype(lhs.get()&rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator& (const Tracked< T > &lhs, U &&rhs) -> decltype(lhs.get()&std::forward< U >(rhs))
template<class T , class U >
auto	madara::knowledge::rcw::operator& (T &&lhs, const Tracked< U > &rhs) -> decltype(std::forward< T >(lhs)&rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator&= (Tracked< T > &lhs, const Tracked< U > &rhs) -> decltype(lhs.get_mut()&=rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator&= (Tracked< T > &lhs, U &&rhs) -> decltype(lhs.get_mut()&=std::forward< U >(rhs))
template<class T , class U >
auto	madara::knowledge::rcw::operator&= (T &lhs, const Tracked< U > &rhs) -> decltype(lhs &=rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator* (const Tracked< T > &lhs, U &&rhs) -> decltype(lhs.get()*std::forward< U >(rhs))
template<class T , class U >
auto	madara::knowledge::rcw::operator* (T &&lhs, const Tracked< U > &rhs) -> decltype(std::forward< T >(lhs)*rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator* (const Tracked< T > &lhs, const Tracked< U > &rhs) -> decltype(lhs.get()*rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator*= (Tracked< T > &lhs, const Tracked< U > &rhs) -> decltype(lhs.get_mut()*=rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator*= (Tracked< T > &lhs, U &&rhs) -> decltype(lhs.get_mut()*=std::forward< U >(rhs))
template<class T , class U >
auto	madara::knowledge::rcw::operator*= (T &lhs, const Tracked< U > &rhs) -> decltype(lhs *=rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator+ (const Tracked< T > &lhs, const Tracked< U > &rhs) -> decltype(lhs.get()+rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator+ (const Tracked< T > &lhs, U &&rhs) -> decltype(lhs.get()+std::forward< U >(rhs))
template<class T , class U >
auto	madara::knowledge::rcw::operator+ (T &&lhs, const Tracked< U > &rhs) -> decltype(std::forward< T >(lhs)+rhs.get())
template<class T >
auto	madara::knowledge::rcw::operator+ (const Tracked< T > &lhs) -> decltype(+lhs.get())
template<class T >
auto	madara::knowledge::rcw::operator++ (Tracked< T > &lhs) -> decltype(++lhs.get_mut())
template<class T >
auto	madara::knowledge::rcw::operator++ (Tracked< T > &lhs, int) -> decltype(lhs.get_mut()++)
template<class T , class U >
auto	madara::knowledge::rcw::operator+= (T &lhs, const Tracked< U > &rhs) -> decltype(lhs+=rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator+= (Tracked< T > &lhs, U &&rhs) -> decltype(lhs.get_mut()+=std::forward< U >(rhs))
template<class T , class U >
auto	madara::knowledge::rcw::operator+= (Tracked< T > &lhs, const Tracked< U > &rhs) -> decltype(lhs.get_mut()+=rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator- (const Tracked< T > &lhs, const Tracked< U > &rhs) -> decltype(lhs.get()-rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator- (const Tracked< T > &lhs, U &&rhs) -> decltype(lhs.get()-std::forward< U >(rhs))
template<class T , class U >
auto	madara::knowledge::rcw::operator- (T &&lhs, const Tracked< U > &rhs) -> decltype(std::forward< T >(lhs)-rhs.get())
template<class T >
auto	madara::knowledge::rcw::operator- (const Tracked< T > &lhs) -> decltype(-lhs.get())
template<class T >
auto	madara::knowledge::rcw::operator-- (Tracked< T > &lhs) -> decltype(--lhs.get_mut())
template<class T >
auto	madara::knowledge::rcw::operator-- (Tracked< T > &lhs, int) -> decltype(lhs.get_mut()--)
template<class T , class U >
auto	madara::knowledge::rcw::operator-= (Tracked< T > &lhs, const Tracked< U > &rhs) -> decltype(lhs.get_mut()-=rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator-= (Tracked< T > &lhs, U &&rhs) -> decltype(lhs.get_mut()-=std::forward< U >(rhs))
template<class T , class U >
auto	madara::knowledge::rcw::operator-= (T &lhs, const Tracked< U > &rhs) -> decltype(lhs-=rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator/ (const Tracked< T > &lhs, const Tracked< U > &rhs) -> decltype(lhs.get()/rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator/ (const Tracked< T > &lhs, U &&rhs) -> decltype(lhs.get()/std::forward< U >(rhs))
template<class T , class U >
auto	madara::knowledge::rcw::operator/ (T &&lhs, const Tracked< U > &rhs) -> decltype(std::forward< T >(lhs)/rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator/= (Tracked< T > &lhs, U &&rhs) -> decltype(lhs.get_mut()/=std::forward< U >(rhs))
template<class T , class U >
auto	madara::knowledge::rcw::operator/= (T &lhs, const Tracked< U > &rhs) -> decltype(lhs/=rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator/= (Tracked< T > &lhs, const Tracked< U > &rhs) -> decltype(lhs.get_mut()/=rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator< (T &&lhs, const Tracked< U > &rhs) -> decltype(std::forward< T >(lhs)< rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator< (const Tracked< T > &lhs, const Tracked< U > &rhs) -> decltype(lhs.get()< rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator< (const Tracked< T > &lhs, U &&rhs) -> decltype(lhs.get()< std::forward< U >(rhs))
template<class T , class U >
auto	madara::knowledge::rcw::operator<< (const Tracked< T > &lhs, const Tracked< U > &rhs) -> decltype(lhs.get()<< rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator<< (const Tracked< T > &lhs, U &&rhs) -> decltype(lhs.get()<< std::forward< U >(rhs))
template<class T , class U >
auto	madara::knowledge::rcw::operator<< (T &&lhs, const Tracked< U > &rhs) -> decltype(std::forward< T >(lhs)<< rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator<<= (Tracked< T > &lhs, const Tracked< U > &rhs) -> decltype(lhs.get_mut()<<=rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator<<= (T &lhs, const Tracked< U > &rhs) -> decltype(lhs<<=rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator<<= (Tracked< T > &lhs, U &&rhs) -> decltype(lhs.get_mut()<<=std::forward< U >(rhs))
template<class T , class U >
auto	madara::knowledge::rcw::operator<= (const Tracked< T > &lhs, const Tracked< U > &rhs) -> decltype(lhs.get()<=rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator<= (const Tracked< T > &lhs, U &&rhs) -> decltype(lhs.get()<=std::forward< U >(rhs))
template<class T , class U >
auto	madara::knowledge::rcw::operator<= (T &&lhs, const Tracked< U > &rhs) -> decltype(std::forward< T >(lhs)<=rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator== (const Tracked< T > &lhs, const Tracked< U > &rhs) -> decltype(lhs.get()==rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator== (const Tracked< T > &lhs, U &&rhs) -> decltype(lhs.get()==std::forward< U >(rhs))
template<class T , class U >
auto	madara::knowledge::rcw::operator== (T &&lhs, const Tracked< U > &rhs) -> decltype(std::forward< T >(lhs)==rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator> (const Tracked< T > &lhs, U &&rhs) -> decltype(lhs.get() >std::forward< U >(rhs))
template<class T , class U >
auto	madara::knowledge::rcw::operator> (T &&lhs, const Tracked< U > &rhs) -> decltype(std::forward< T >(lhs) >rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator> (const Tracked< T > &lhs, const Tracked< U > &rhs) -> decltype(lhs.get() >rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator>= (const Tracked< T > &lhs, const Tracked< U > &rhs) -> decltype(lhs.get() >=rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator>= (const Tracked< T > &lhs, U &&rhs) -> decltype(lhs.get() >=std::forward< U >(rhs))
template<class T , class U >
auto	madara::knowledge::rcw::operator>= (T &&lhs, const Tracked< U > &rhs) -> decltype(std::forward< T >(lhs) >=rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator>> (T &&lhs, const Tracked< U > &rhs) -> decltype(std::forward< T >(lhs) >>rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator>> (const Tracked< T > &lhs, U &&rhs) -> decltype(lhs.get() >>std::forward< U >(rhs))
template<class T , class U >
auto	madara::knowledge::rcw::operator>> (const Tracked< T > &lhs, const Tracked< U > &rhs) -> decltype(lhs.get() >>rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator>>= (Tracked< T > &lhs, const Tracked< U > &rhs) -> decltype(lhs.get_mut() >>=rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator>>= (T &lhs, const Tracked< U > &rhs) -> decltype(lhs >>=rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator>>= (Tracked< T > &lhs, U &&rhs) -> decltype(lhs.get_mut() >>=std::forward< U >(rhs))
template<class T , class U >
auto	madara::knowledge::rcw::operator^ (T &&lhs, const Tracked< U > &rhs) -> decltype(std::forward< T >(lhs)^rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator^ (const Tracked< T > &lhs, const Tracked< U > &rhs) -> decltype(lhs.get()^rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator^ (const Tracked< T > &lhs, U &&rhs) -> decltype(lhs.get()^std::forward< U >(rhs))
template<class T , class U >
auto	madara::knowledge::rcw::operator^= (Tracked< T > &lhs, const Tracked< U > &rhs) -> decltype(lhs.get_mut()^=rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator^= (Tracked< T > &lhs, U &&rhs) -> decltype(lhs.get_mut()^=std::forward< U >(rhs))
template<class T , class U >
auto	madara::knowledge::rcw::operator^= (T &lhs, const Tracked< U > &rhs) -> decltype(lhs^=rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator| (const Tracked< T > &lhs, const Tracked< U > &rhs) -> decltype(lhs.get()|rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator| (const Tracked< T > &lhs, U &&rhs) -> decltype(lhs.get()|std::forward< U >(rhs))
template<class T , class U >
auto	madara::knowledge::rcw::operator| (T &&lhs, const Tracked< U > &rhs) -> decltype(std::forward< T >(lhs)|rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator|= (T &lhs, const Tracked< U > &rhs) -> decltype(lhs|=rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator|= (Tracked< T > &lhs, const Tracked< U > &rhs) -> decltype(lhs.get_mut()|=rhs.get())
template<class T , class U >
auto	madara::knowledge::rcw::operator|= (Tracked< T > &lhs, U &&rhs) -> decltype(lhs.get_mut()|=std::forward< U >(rhs))
template<class T >
auto	madara::knowledge::rcw::operator~ (const Tracked< T > &lhs) -> decltype(~lhs.get())
template<typename T >
void	madara::knowledge::rcw::set_value (Tracked< T > &t, decltype(get_value(t.get())) v)
	Set value of Tracked type. More...
void	madara::knowledge::rcw::set_value (Tracked< std::string > &t, size_t i, char v)
	Set value of given index of Tracked string type. More...
template<typename T >
void	madara::knowledge::rcw::set_value (Tracked< std::vector< T >> &t, size_t i, const T &v)
	Set value at index of Tracked vector. More...
template<class T >
Tracked< typename std::decay< T >::type >	madara::knowledge::rcw::track (T &&val)
	Create a tracked version of a given object. More...

Detailed Description

Author

David Kyle dskyl.nosp@m.e@se.nosp@m.i.cmu.nosp@m..edu

Implements Tracked class, which wraps types and tracks whether they have been modified

Definition in file Tracked.h.

Macro Definition Documentation

#define MADARA_AUTOTYPE_BODY

(

body

)

-> decltype(body) { return (body); }

Definition at line 230 of file Tracked.h.

#define MADARA_MAKE_BINARY_ARITH_OP

(

op

)

Value:

template<class T, class U> \
  auto operator op(const Tracked<T> &lhs, const Tracked<U> &rhs) \
    MADARA_AUTOTYPE_BODY(lhs.get() op rhs.get()) \
  template<class T, class U> \
  auto operator op(const Tracked<T> &lhs, U &&rhs) \
    MADARA_AUTOTYPE_BODY(lhs.get() op std::forward<U>(rhs)) \
  template<class T, class U> \
  auto operator op(T &&lhs, const Tracked<U> &rhs) \
    MADARA_AUTOTYPE_BODY(std::forward<T>(lhs) op rhs.get()) \
  MADARA_MAKE_COMPOUND_OP(op)

Definition at line 262 of file Tracked.h.

#define MADARA_MAKE_BINARY_COMPARE_OP

(

op

)

Value:

template<class T, class U> \
  auto operator op(const Tracked<T> &lhs, const Tracked<U> &rhs) \
    MADARA_AUTOTYPE_BODY(lhs.get() op rhs.get()) \
  template<class T, class U> \
  auto operator op(const Tracked<T> &lhs, U &&rhs) \
    MADARA_AUTOTYPE_BODY(lhs.get() op std::forward<U>(rhs)) \
  template<class T, class U> \
  auto operator op(T &&lhs, const Tracked<U> &rhs) \
    MADARA_AUTOTYPE_BODY(std::forward<T>(lhs) op rhs.get())

Definition at line 233 of file Tracked.h.

#define MADARA_MAKE_COMPOUND_OP

(

op

)

Value:

template<class T, class U> \
  auto operator op##=(Tracked<T> &lhs, const Tracked<U> &rhs) \
    MADARA_AUTOTYPE_BODY(lhs.get_mut() op##= rhs.get()) \
  template<class T, class U> \
  auto operator op##=(Tracked<T> &lhs, U &&rhs) \
    MADARA_AUTOTYPE_BODY(lhs.get_mut() op##= std::forward<U>(rhs)) \
  template<class T, class U> \
  auto operator op##=(T &lhs, const Tracked<U> &rhs) \
    MADARA_AUTOTYPE_BODY(lhs op##= rhs.get())

Definition at line 251 of file Tracked.h.

#define MADARA_MAKE_INCDEC_OP

(

op

)

Value:

template<class T> auto operator op(Tracked<T> &lhs) \
    MADARA_AUTOTYPE_BODY(op lhs.get_mut()) \
  template<class T> auto operator op(Tracked<T> &lhs, int) \
    MADARA_AUTOTYPE_BODY(lhs.get_mut() op)

Definition at line 295 of file Tracked.h.

#define MADARA_MAKE_UNARY_ARITH_OP

(

op

)

Value:

template<class T> \
  auto operator op(const Tracked<T> &lhs) \
    MADARA_AUTOTYPE_BODY(op lhs.get())

Definition at line 285 of file Tracked.h.