Top

rosetta.basic.datacache._basic_datacache_ module

Classes

class BasicDataCache

A DataCache storing objects derived from basic::datacache::CacheableData. See DataCache base class for usage details.

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: DataCache_T_basic_datacache_CacheableData_T.__init__

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (int)n_slots) -> None : size constructor [in] n_types The number of slots for this DataCache.

C++ signature :
    void __init__(_object*,unsigned long)

init( (object)arg1, (BasicDataCache)rval) -> None : copy constructor

C++ signature :
    void __init__(_object*,basic::datacache::BasicDataCache)

def assign(

...)

Inheritance: DataCache_T_basic_datacache_CacheableData_T.assign

assign( (BasicDataCache)arg1, (BasicDataCache)rval) -> BasicDataCache : copy assignment

C++ signature : basic::datacache::BasicDataCache {lvalue} assign(basic::datacache::BasicDataCache {lvalue},basic::datacache::BasicDataCache)

def clear(

...)

Inheritance: DataCache_T_basic_datacache_CacheableData_T.clear

clear( (DataCache_T_basic_datacache_CacheableData_T)arg1) -> None : clear all stored data

C++ signature :
    void clear(basic::datacache::DataCache<basic::datacache::CacheableData> {lvalue})

clear( (DataCache_T_basic_datacache_CacheableData_T)arg1, (int)slot) -> None : clear the object in a selected slot

C++ signature :
    void clear(basic::datacache::DataCache<basic::datacache::CacheableData> {lvalue},unsigned long)

def get(

...)

Inheritance: DataCache_T_basic_datacache_CacheableData_T.get

get( (DataCache_T_basic_datacache_CacheableData_T)arg1, (int)slot) -> CacheableData : get base class reference to the object stored in the slot

C++ signature :
    basic::datacache::CacheableData get(basic::datacache::DataCache<basic::datacache::CacheableData> {lvalue},unsigned long)

get( (DataCache_T_basic_datacache_CacheableData_T)arg1, (int)slot) -> CacheableData : get base class reference to object stored in the slot

C++ signature :
    basic::datacache::CacheableData {lvalue} get(basic::datacache::DataCache<basic::datacache::CacheableData> {lvalue},unsigned long)

def get_const_ptr(

...)

Inheritance: DataCache_T_basic_datacache_CacheableData_T.get_const_ptr

get_const_ptr( (DataCache_T_basic_datacache_CacheableData_T)arg1, (int)slot) -> CacheableData : get base class owning ptr to object stored in the slot

C++ signature : boost::shared_ptr get_const_ptr(basic::datacache::DataCache {lvalue},unsigned long)

def get_ptr(

...)

Inheritance: DataCache_T_basic_datacache_CacheableData_T.get_ptr

get_ptr( (DataCache_T_basic_datacache_CacheableData_T)arg1, (int)slot) -> CacheableData : get base class owning ptr to object stored in the slot

C++ signature : boost::shared_ptr get_ptr(basic::datacache::DataCache {lvalue},unsigned long)

def get_raw_const_ptr(

...)

Inheritance: DataCache_T_basic_datacache_CacheableData_T.get_raw_const_ptr

get_raw_const_ptr( (DataCache_T_basic_datacache_CacheableData_T)arg1, (int)slot) -> CacheableData : get base class raw ptr to object stored in the slot

C++ signature : basic::datacache::CacheableData const* get_raw_const_ptr(basic::datacache::DataCache {lvalue},unsigned long)

def get_raw_ptr(

...)

Inheritance: DataCache_T_basic_datacache_CacheableData_T.get_raw_ptr

get_raw_ptr( (DataCache_T_basic_datacache_CacheableData_T)arg1, (int)slot) -> CacheableData : get base class raw ptr to object stored in the slot

C++ signature : basic::datacache::CacheableData* get_raw_ptr(basic::datacache::DataCache {lvalue},unsigned long)

def has(

...)

Inheritance: DataCache_T_basic_datacache_CacheableData_T.has

has( (DataCache_T_basic_datacache_CacheableData_T)arg1, (int)slot) -> bool : is there an object in the slot?

C++ signature : bool has(basic::datacache::DataCache {lvalue},unsigned long)

def resize(

...)

Inheritance: DataCache_T_basic_datacache_CacheableData_T.resize

resize( (DataCache_T_basic_datacache_CacheableData_T)arg1, (int)n_slots) -> None : resize the cache for the given number of slots [in] n_slots The new number of slots.

C++ signature : void resize(basic::datacache::DataCache {lvalue},unsigned long)

def set(

...)

Inheritance: DataCache_T_basic_datacache_CacheableData_T.set

set( (DataCache_T_basic_datacache_CacheableData_T)arg1, (int)slot, (CPP_CacheableData)new_data) -> None : store data in the given slot [in] The slot to use. [in] observer The data to store -- data is not cloned.

C++ signature : void set(basic::datacache::DataCache {lvalue},unsigned long,boost::shared_ptr)

def size(

...)

Inheritance: DataCache_T_basic_datacache_CacheableData_T.size

size( (DataCache_T_basic_datacache_CacheableData_T)arg1) -> int : the number of slots in this cache

C++ signature : unsigned long size(basic::datacache::DataCache {lvalue})

class BasicDataCacheAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (BasicDataCacheAP)arg1) -> BasicDataCache :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class BasicDataCacheCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (BasicDataCacheCAP)arg1) -> BasicDataCache :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class CacheableData

base class for data storable within a DataCache

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def clone(

...)

clone( (CacheableData)arg1) -> CacheableData : basic/datacache/CacheableData.hh:54

C++ signature :
    boost::shared_ptr<basic::datacache::CacheableData> clone(basic::datacache::CacheableData {lvalue})

clone( (CacheableData)arg1) -> None :

C++ signature :
    void clone(boost::shared_ptr<CacheableData_exposer_callback> {lvalue})

def get_self_ptr(

...)

get_self_ptr( (CacheableData)arg1) -> CacheableData : self pointers

C++ signature :
    boost::shared_ptr<basic::datacache::CacheableData const> get_self_ptr(basic::datacache::CacheableData {lvalue})

get_self_ptr( (CacheableData)arg1) -> CacheableData : basic/datacache/CacheableData.hh:47

C++ signature :
    boost::shared_ptr<basic::datacache::CacheableData> get_self_ptr(basic::datacache::CacheableData {lvalue})

def get_self_weak_ptr(

...)

get_self_weak_ptr( (CacheableData)arg1) -> CacheableDataCAP : basic/datacache/CacheableData.hh:48

C++ signature :
    boost::weak_ptr<basic::datacache::CacheableData const> get_self_weak_ptr(basic::datacache::CacheableData {lvalue})

get_self_weak_ptr( (CacheableData)arg1) -> CacheableDataAP : basic/datacache/CacheableData.hh:49

C++ signature :
    boost::weak_ptr<basic::datacache::CacheableData> get_self_weak_ptr(basic::datacache::CacheableData {lvalue})

class CacheableDataAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (CacheableDataAP)arg1) -> CacheableData :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class CacheableDataCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (CacheableDataCAP)arg1) -> CacheableData :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class CacheableString

Wrapper for std::string

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: CacheableData.__init__

init( (object)arg1, (str)str) -> None : basic/datacache/CacheableString.hh:50

C++ signature :
    void __init__(_object*,std::string)

init( (object)arg1, (CacheableString)) -> None : Wrapper for std::string

C++ signature :
    void __init__(_object*,basic::datacache::CacheableString)

def clone(

...)

Inheritance: CacheableData.clone

clone( (CacheableString)arg1) -> CacheableData : basic/datacache/CacheableString.hh:52

C++ signature :
    boost::shared_ptr<basic::datacache::CacheableData> clone(basic::datacache::CacheableString {lvalue})

clone( (CacheableString)arg1) -> CacheableData :

C++ signature :
    boost::shared_ptr<basic::datacache::CacheableData> clone(CacheableString_exposer_callback {lvalue})

def get_self_ptr(

...)

Inheritance: CacheableData.get_self_ptr

get_self_ptr( (CacheableData)arg1) -> CacheableData : self pointers

C++ signature :
    boost::shared_ptr<basic::datacache::CacheableData const> get_self_ptr(basic::datacache::CacheableData {lvalue})

get_self_ptr( (CacheableData)arg1) -> CacheableData : basic/datacache/CacheableData.hh:47

C++ signature :
    boost::shared_ptr<basic::datacache::CacheableData> get_self_ptr(basic::datacache::CacheableData {lvalue})

def get_self_weak_ptr(

...)

Inheritance: CacheableData.get_self_weak_ptr

get_self_weak_ptr( (CacheableData)arg1) -> CacheableDataCAP : basic/datacache/CacheableData.hh:48

C++ signature :
    boost::weak_ptr<basic::datacache::CacheableData const> get_self_weak_ptr(basic::datacache::CacheableData {lvalue})

get_self_weak_ptr( (CacheableData)arg1) -> CacheableDataAP : basic/datacache/CacheableData.hh:49

C++ signature :
    boost::weak_ptr<basic::datacache::CacheableData> get_self_weak_ptr(basic::datacache::CacheableData {lvalue})

def str(

...)

str( (CacheableString)arg1) -> str : basic/datacache/CacheableString.hh:53

C++ signature :
    std::string str(basic::datacache::CacheableString {lvalue})

str( (CacheableString)arg1) -> str :

C++ signature :
    std::string str(CacheableString_exposer_callback {lvalue})

class CacheableStringAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (CacheableStringAP)arg1) -> CacheableString :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class CacheableStringCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (CacheableStringCAP)arg1) -> CacheableString :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class CacheableStringFloatMap

Wrapper for std::map< std::string, float >

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: CacheableData.__init__

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (CacheableStringFloatMap)) -> None : Wrapper for std::map< std::string, float >

C++ signature :
    void __init__(_object*,basic::datacache::CacheableStringFloatMap)

def clone(

...)

Inheritance: CacheableData.clone

clone( (CacheableStringFloatMap)arg1) -> CacheableData : basic/datacache/CacheableStringFloatMap.hh:53

C++ signature :
    boost::shared_ptr<basic::datacache::CacheableData> clone(basic::datacache::CacheableStringFloatMap {lvalue})

clone( (CacheableStringFloatMap)arg1) -> CacheableData :

C++ signature :
    boost::shared_ptr<basic::datacache::CacheableData> clone(CacheableStringFloatMap_exposer_callback {lvalue})

def get_self_ptr(

...)

Inheritance: CacheableData.get_self_ptr

get_self_ptr( (CacheableData)arg1) -> CacheableData : self pointers

C++ signature :
    boost::shared_ptr<basic::datacache::CacheableData const> get_self_ptr(basic::datacache::CacheableData {lvalue})

get_self_ptr( (CacheableData)arg1) -> CacheableData : basic/datacache/CacheableData.hh:47

C++ signature :
    boost::shared_ptr<basic::datacache::CacheableData> get_self_ptr(basic::datacache::CacheableData {lvalue})

def get_self_weak_ptr(

...)

Inheritance: CacheableData.get_self_weak_ptr

get_self_weak_ptr( (CacheableData)arg1) -> CacheableDataCAP : basic/datacache/CacheableData.hh:48

C++ signature :
    boost::weak_ptr<basic::datacache::CacheableData const> get_self_weak_ptr(basic::datacache::CacheableData {lvalue})

get_self_weak_ptr( (CacheableData)arg1) -> CacheableDataAP : basic/datacache/CacheableData.hh:49

C++ signature :
    boost::weak_ptr<basic::datacache::CacheableData> get_self_weak_ptr(basic::datacache::CacheableData {lvalue})

def map(

...)

map( (CacheableStringFloatMap)arg1) -> object : basic/datacache/CacheableStringFloatMap.hh:55

C++ signature :
    std::map<std::string, float, std::less<std::string>, std::allocator<std::pair<std::string const, float> > > {lvalue} map(basic::datacache::CacheableStringFloatMap {lvalue})

map( (CacheableStringFloatMap)arg1) -> object :

C++ signature :
    std::map<std::string, float, std::less<std::string>, std::allocator<std::pair<std::string const, float> > > {lvalue} map(CacheableStringFloatMap_exposer_callback {lvalue})

map( (CacheableStringFloatMap)arg1) -> object : basic/datacache/CacheableStringFloatMap.hh:56

C++ signature :
    std::map<std::string, float, std::less<std::string>, std::allocator<std::pair<std::string const, float> > > map(basic::datacache::CacheableStringFloatMap {lvalue})

class CacheableStringFloatMapAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (CacheableStringFloatMapAP)arg1) -> CacheableStringFloatMap :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class CacheableStringFloatMapCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (CacheableStringFloatMapCAP)arg1) -> CacheableStringFloatMap :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class CacheableStringMap

Wrapper for a map< string, string >.

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: CacheableData.__init__

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (CacheableStringMap)) -> None : Wrapper for a map< string, string >.

C++ signature :
    void __init__(_object*,basic::datacache::CacheableStringMap)

def clone(

...)

Inheritance: CacheableData.clone

clone( (CacheableStringMap)arg1) -> CacheableData : basic/datacache/CacheableStringMap.hh:55

C++ signature :
    boost::shared_ptr<basic::datacache::CacheableData> clone(basic::datacache::CacheableStringMap {lvalue})

clone( (CacheableStringMap)arg1) -> CacheableData :

C++ signature :
    boost::shared_ptr<basic::datacache::CacheableData> clone(CacheableStringMap_exposer_callback {lvalue})

def get_self_ptr(

...)

Inheritance: CacheableData.get_self_ptr

get_self_ptr( (CacheableData)arg1) -> CacheableData : self pointers

C++ signature :
    boost::shared_ptr<basic::datacache::CacheableData const> get_self_ptr(basic::datacache::CacheableData {lvalue})

get_self_ptr( (CacheableData)arg1) -> CacheableData : basic/datacache/CacheableData.hh:47

C++ signature :
    boost::shared_ptr<basic::datacache::CacheableData> get_self_ptr(basic::datacache::CacheableData {lvalue})

def get_self_weak_ptr(

...)

Inheritance: CacheableData.get_self_weak_ptr

get_self_weak_ptr( (CacheableData)arg1) -> CacheableDataCAP : basic/datacache/CacheableData.hh:48

C++ signature :
    boost::weak_ptr<basic::datacache::CacheableData const> get_self_weak_ptr(basic::datacache::CacheableData {lvalue})

get_self_weak_ptr( (CacheableData)arg1) -> CacheableDataAP : basic/datacache/CacheableData.hh:49

C++ signature :
    boost::weak_ptr<basic::datacache::CacheableData> get_self_weak_ptr(basic::datacache::CacheableData {lvalue})

def map(

...)

map( (CacheableStringMap)arg1) -> map_string_string : basic/datacache/CacheableStringMap.hh:59

C++ signature :
    std::map<std::string, std::string, std::less<std::string>, std::allocator<std::pair<std::string const, std::string> > > {lvalue} map(basic::datacache::CacheableStringMap {lvalue})

map( (CacheableStringMap)arg1) -> map_string_string :

C++ signature :
    std::map<std::string, std::string, std::less<std::string>, std::allocator<std::pair<std::string const, std::string> > > {lvalue} map(CacheableStringMap_exposer_callback {lvalue})

map( (CacheableStringMap)arg1) -> map_string_string : basic/datacache/CacheableStringMap.hh:63

C++ signature :
    std::map<std::string, std::string, std::less<std::string>, std::allocator<std::pair<std::string const, std::string> > > map(basic::datacache::CacheableStringMap {lvalue})

class CacheableStringMapAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (CacheableStringMapAP)arg1) -> CacheableStringMap :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class CacheableStringMapCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (CacheableStringMapCAP)arg1) -> CacheableStringMap :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class DataCache_CacheableData

basic/datacache/DataCache.hh:370

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: DataCache_T_basic_datacache_CacheableData_T.__init__

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def assign(

...)

Inheritance: DataCache_T_basic_datacache_CacheableData_T.assign

assign( (DataCache_T_basic_datacache_CacheableData_T)arg1, (DataCache_T_basic_datacache_CacheableData_T)src) -> DataCache_T_basic_datacache_CacheableData_T : copy assignment

C++ signature : basic::datacache::DataCache {lvalue} assign(basic::datacache::DataCache {lvalue},basic::datacache::DataCache)

def clear(

...)

Inheritance: DataCache_T_basic_datacache_CacheableData_T.clear

clear( (DataCache_T_basic_datacache_CacheableData_T)arg1) -> None : clear all stored data

C++ signature :
    void clear(basic::datacache::DataCache<basic::datacache::CacheableData> {lvalue})

clear( (DataCache_T_basic_datacache_CacheableData_T)arg1, (int)slot) -> None : clear the object in a selected slot

C++ signature :
    void clear(basic::datacache::DataCache<basic::datacache::CacheableData> {lvalue},unsigned long)

def get(

...)

Inheritance: DataCache_T_basic_datacache_CacheableData_T.get

get( (DataCache_T_basic_datacache_CacheableData_T)arg1, (int)slot) -> CacheableData : get base class reference to the object stored in the slot

C++ signature :
    basic::datacache::CacheableData get(basic::datacache::DataCache<basic::datacache::CacheableData> {lvalue},unsigned long)

get( (DataCache_T_basic_datacache_CacheableData_T)arg1, (int)slot) -> CacheableData : get base class reference to object stored in the slot

C++ signature :
    basic::datacache::CacheableData {lvalue} get(basic::datacache::DataCache<basic::datacache::CacheableData> {lvalue},unsigned long)

def get_const_ptr(

...)

Inheritance: DataCache_T_basic_datacache_CacheableData_T.get_const_ptr

get_const_ptr( (DataCache_T_basic_datacache_CacheableData_T)arg1, (int)slot) -> CacheableData : get base class owning ptr to object stored in the slot

C++ signature : boost::shared_ptr get_const_ptr(basic::datacache::DataCache {lvalue},unsigned long)

def get_ptr(

...)

Inheritance: DataCache_T_basic_datacache_CacheableData_T.get_ptr

get_ptr( (DataCache_T_basic_datacache_CacheableData_T)arg1, (int)slot) -> CacheableData : get base class owning ptr to object stored in the slot

C++ signature : boost::shared_ptr get_ptr(basic::datacache::DataCache {lvalue},unsigned long)

def get_raw_const_ptr(

...)

Inheritance: DataCache_T_basic_datacache_CacheableData_T.get_raw_const_ptr

get_raw_const_ptr( (DataCache_T_basic_datacache_CacheableData_T)arg1, (int)slot) -> CacheableData : get base class raw ptr to object stored in the slot

C++ signature : basic::datacache::CacheableData const* get_raw_const_ptr(basic::datacache::DataCache {lvalue},unsigned long)

def get_raw_ptr(

...)

Inheritance: DataCache_T_basic_datacache_CacheableData_T.get_raw_ptr

get_raw_ptr( (DataCache_T_basic_datacache_CacheableData_T)arg1, (int)slot) -> CacheableData : get base class raw ptr to object stored in the slot

C++ signature : basic::datacache::CacheableData* get_raw_ptr(basic::datacache::DataCache {lvalue},unsigned long)

def has(

...)

Inheritance: DataCache_T_basic_datacache_CacheableData_T.has

has( (DataCache_T_basic_datacache_CacheableData_T)arg1, (int)slot) -> bool : is there an object in the slot?

C++ signature : bool has(basic::datacache::DataCache {lvalue},unsigned long)

def resize(

...)

Inheritance: DataCache_T_basic_datacache_CacheableData_T.resize

resize( (DataCache_T_basic_datacache_CacheableData_T)arg1, (int)n_slots) -> None : resize the cache for the given number of slots [in] n_slots The new number of slots.

C++ signature : void resize(basic::datacache::DataCache {lvalue},unsigned long)

def set(

...)

Inheritance: DataCache_T_basic_datacache_CacheableData_T.set

set( (DataCache_T_basic_datacache_CacheableData_T)arg1, (int)slot, (CPP_CacheableData)new_data) -> None : store data in the given slot [in] The slot to use. [in] observer The data to store -- data is not cloned.

C++ signature : void set(basic::datacache::DataCache {lvalue},unsigned long,boost::shared_ptr)

def size(

...)

Inheritance: DataCache_T_basic_datacache_CacheableData_T.size

size( (DataCache_T_basic_datacache_CacheableData_T)arg1) -> int : the number of slots in this cache

C++ signature : unsigned long size(basic::datacache::DataCache {lvalue})

class DataCache_CacheableDataAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (DataCache_CacheableDataAP)arg1) -> DataCache_CacheableData :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class DataCache_CacheableDataCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (DataCache_CacheableDataCAP)arg1) -> DataCache_CacheableData :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class DataCache_T_basic_datacache_CacheableData_T

Indexed storage for objects derived from a ReferenceCountable data type. Intended for use as a generic data cache by storing objects derived from a ReferenceCountable data type in a unique slot designated by an integer id (enum, size index, etc.). The DataCache will only store one object per slot/id. For example, see the PoseDataCache used in core::pose::Pose, which is indexed by the enum basic::pose::datacache:CacheableDataType. Currently when data is set(), it is not cloned -- classes deriving from DataCache should remember to overload set() if they need cloning behavior. @tparam Data Class derived from utility::pointer::ReferenceCount that defines a virtual clone() method.

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (int)n_slots) -> None : size constructor [in] n_types The number of slots for this DataCache.

C++ signature :
    void __init__(_object*,unsigned long)

init( (object)arg1, (DataCache_T_basic_datacache_CacheableData_T)src) -> None : copy constructor

C++ signature :
    void __init__(_object*,basic::datacache::DataCache<basic::datacache::CacheableData>)

def assign(

...)

assign( (DataCache_T_basic_datacache_CacheableData_T)arg1, (DataCache_T_basic_datacache_CacheableData_T)src) -> DataCache_T_basic_datacache_CacheableData_T : copy assignment

C++ signature : basic::datacache::DataCache {lvalue} assign(basic::datacache::DataCache {lvalue},basic::datacache::DataCache)

def clear(

...)

clear( (DataCache_T_basic_datacache_CacheableData_T)arg1) -> None : clear all stored data

C++ signature :
    void clear(basic::datacache::DataCache<basic::datacache::CacheableData> {lvalue})

clear( (DataCache_T_basic_datacache_CacheableData_T)arg1, (int)slot) -> None : clear the object in a selected slot

C++ signature :
    void clear(basic::datacache::DataCache<basic::datacache::CacheableData> {lvalue},unsigned long)

def get(

...)

get( (DataCache_T_basic_datacache_CacheableData_T)arg1, (int)slot) -> CacheableData : get base class reference to the object stored in the slot

C++ signature :
    basic::datacache::CacheableData get(basic::datacache::DataCache<basic::datacache::CacheableData> {lvalue},unsigned long)

get( (DataCache_T_basic_datacache_CacheableData_T)arg1, (int)slot) -> CacheableData : get base class reference to object stored in the slot

C++ signature :
    basic::datacache::CacheableData {lvalue} get(basic::datacache::DataCache<basic::datacache::CacheableData> {lvalue},unsigned long)

def get_const_ptr(

...)

get_const_ptr( (DataCache_T_basic_datacache_CacheableData_T)arg1, (int)slot) -> CacheableData : get base class owning ptr to object stored in the slot

C++ signature : boost::shared_ptr get_const_ptr(basic::datacache::DataCache {lvalue},unsigned long)

def get_ptr(

...)

get_ptr( (DataCache_T_basic_datacache_CacheableData_T)arg1, (int)slot) -> CacheableData : get base class owning ptr to object stored in the slot

C++ signature : boost::shared_ptr get_ptr(basic::datacache::DataCache {lvalue},unsigned long)

def get_raw_const_ptr(

...)

get_raw_const_ptr( (DataCache_T_basic_datacache_CacheableData_T)arg1, (int)slot) -> CacheableData : get base class raw ptr to object stored in the slot

C++ signature : basic::datacache::CacheableData const* get_raw_const_ptr(basic::datacache::DataCache {lvalue},unsigned long)

def get_raw_ptr(

...)

get_raw_ptr( (DataCache_T_basic_datacache_CacheableData_T)arg1, (int)slot) -> CacheableData : get base class raw ptr to object stored in the slot

C++ signature : basic::datacache::CacheableData* get_raw_ptr(basic::datacache::DataCache {lvalue},unsigned long)

def has(

...)

has( (DataCache_T_basic_datacache_CacheableData_T)arg1, (int)slot) -> bool : is there an object in the slot?

C++ signature : bool has(basic::datacache::DataCache {lvalue},unsigned long)

def resize(

...)

resize( (DataCache_T_basic_datacache_CacheableData_T)arg1, (int)n_slots) -> None : resize the cache for the given number of slots [in] n_slots The new number of slots.

C++ signature : void resize(basic::datacache::DataCache {lvalue},unsigned long)

def set(

...)

set( (DataCache_T_basic_datacache_CacheableData_T)arg1, (int)slot, (CPP_CacheableData)new_data) -> None : store data in the given slot [in] The slot to use. [in] observer The data to store -- data is not cloned.

C++ signature : void set(basic::datacache::DataCache {lvalue},unsigned long,boost::shared_ptr)

def size(

...)

size( (DataCache_T_basic_datacache_CacheableData_T)arg1) -> int : the number of slots in this cache

C++ signature : unsigned long size(basic::datacache::DataCache {lvalue})

class DataCache_T_basic_datacache_CacheableData_TAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (DataCache_T_basic_datacache_CacheableData_TAP)arg1) -> DataCache_T_basic_datacache_CacheableData_T :

C++ signature : boost::shared_ptr > get(boost::weak_ptr >)

class DataCache_T_basic_datacache_CacheableData_TCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (DataCache_T_basic_datacache_CacheableData_TCAP)arg1) -> DataCache_T_basic_datacache_CacheableData_T :

C++ signature : boost::shared_ptr const> get(boost::weak_ptr const>)

class DataMap

general-purpose store for any reference-count derived object

Ancestors (in MRO)

  • DataMap
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (DataMap)) -> None : general-purpose store for any reference-count derived object

C++ signature :
    void __init__(_object*,basic::datacache::DataMap)

def add(

...)

add( (DataMap)arg1, (str)type, (str)name, (object)op) -> bool : basic/datacache/DataMap.hh:58

C++ signature : bool add(basic::datacache::DataMap {lvalue},std::string,std::string,boost::shared_ptr)

def begin(

...)

begin( (DataMap)arg1) -> object : basic/datacache/DataMap.hh:48

C++ signature :
    std::_Rb_tree_iterator<std::pair<std::string const, std::map<std::string, boost::shared_ptr<utility::pointer::ReferenceCount>, std::less<std::string>, std::allocator<std::pair<std::string const, boost::shared_ptr<utility::pointer::ReferenceCount> > > > > > begin(basic::datacache::DataMap {lvalue})

begin( (DataMap)arg1) -> object : basic/datacache/DataMap.hh:50

C++ signature :
    std::_Rb_tree_const_iterator<std::pair<std::string const, std::map<std::string, boost::shared_ptr<utility::pointer::ReferenceCount>, std::less<std::string>, std::allocator<std::pair<std::string const, boost::shared_ptr<utility::pointer::ReferenceCount> > > > > > begin(basic::datacache::DataMap {lvalue})

def end(

...)

end( (DataMap)arg1) -> object : basic/datacache/DataMap.hh:49

C++ signature :
    std::_Rb_tree_iterator<std::pair<std::string const, std::map<std::string, boost::shared_ptr<utility::pointer::ReferenceCount>, std::less<std::string>, std::allocator<std::pair<std::string const, boost::shared_ptr<utility::pointer::ReferenceCount> > > > > > end(basic::datacache::DataMap {lvalue})

end( (DataMap)arg1) -> object : basic/datacache/DataMap.hh:51

C++ signature :
    std::_Rb_tree_const_iterator<std::pair<std::string const, std::map<std::string, boost::shared_ptr<utility::pointer::ReferenceCount>, std::less<std::string>, std::allocator<std::pair<std::string const, boost::shared_ptr<utility::pointer::ReferenceCount> > > > > > end(basic::datacache::DataMap {lvalue})

def has(

...)

has( (DataMap)arg1, (str)type [, (str)name='']) -> bool : basic/datacache/DataMap.hh:59

C++ signature : bool has(basic::datacache::DataMap {lvalue},std::string [,std::string=''])

def size(

...)

size( (DataMap)arg1) -> int : returns the size of the map (how many different types are in data_map_

C++ signature : unsigned long size(basic::datacache::DataMap {lvalue})

class DataMapAP

Ancestors (in MRO)

  • DataMapAP
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (DataMapAP)arg1) -> DataMap :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class DataMapCAP

Ancestors (in MRO)

  • DataMapCAP
  • Boost.Python.instance
  • __builtin__.object

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (DataMapCAP)arg1) -> DataMap :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class DiagnosticData

Wrapper for std::map

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: CacheableData.__init__

init( (object)arg1, (map_string_Real)data_in) -> None : basic/datacache/DiagnosticData.hh:53

C++ signature :
    void __init__(_object*,std::map<std::string, double, std::less<std::string>, std::allocator<std::pair<std::string const, double> > >)

init( (object)arg1, (DiagnosticData)) -> None : Wrapper for std::map

C++ signature :
    void __init__(_object*,basic::datacache::DiagnosticData)

def clone(

...)

Inheritance: CacheableData.clone

clone( (DiagnosticData)arg1) -> CacheableData : basic/datacache/DiagnosticData.hh:55

C++ signature :
    boost::shared_ptr<basic::datacache::CacheableData> clone(basic::datacache::DiagnosticData {lvalue})

clone( (DiagnosticData)arg1) -> CacheableData :

C++ signature :
    boost::shared_ptr<basic::datacache::CacheableData> clone(DiagnosticData_exposer_callback {lvalue})

def data(

...)

data( (DiagnosticData)arg1) -> map_string_Real : basic/datacache/DiagnosticData.hh:56

C++ signature :
    std::map<std::string, double, std::less<std::string>, std::allocator<std::pair<std::string const, double> > > data(basic::datacache::DiagnosticData {lvalue})

data( (DiagnosticData)arg1) -> map_string_Real :

C++ signature :
    std::map<std::string, double, std::less<std::string>, std::allocator<std::pair<std::string const, double> > > data(DiagnosticData_exposer_callback {lvalue})

def get_self_ptr(

...)

Inheritance: CacheableData.get_self_ptr

get_self_ptr( (CacheableData)arg1) -> CacheableData : self pointers

C++ signature :
    boost::shared_ptr<basic::datacache::CacheableData const> get_self_ptr(basic::datacache::CacheableData {lvalue})

get_self_ptr( (CacheableData)arg1) -> CacheableData : basic/datacache/CacheableData.hh:47

C++ signature :
    boost::shared_ptr<basic::datacache::CacheableData> get_self_ptr(basic::datacache::CacheableData {lvalue})

def get_self_weak_ptr(

...)

Inheritance: CacheableData.get_self_weak_ptr

get_self_weak_ptr( (CacheableData)arg1) -> CacheableDataCAP : basic/datacache/CacheableData.hh:48

C++ signature :
    boost::weak_ptr<basic::datacache::CacheableData const> get_self_weak_ptr(basic::datacache::CacheableData {lvalue})

get_self_weak_ptr( (CacheableData)arg1) -> CacheableDataAP : basic/datacache/CacheableData.hh:49

C++ signature :
    boost::weak_ptr<basic::datacache::CacheableData> get_self_weak_ptr(basic::datacache::CacheableData {lvalue})

class DiagnosticDataAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (DiagnosticDataAP)arg1) -> DiagnosticData :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class DiagnosticDataCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (DiagnosticDataCAP)arg1) -> DiagnosticData :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class HierarchicalDataMap

A data map designed to help create hierarchies with complicated shared data requirements. To explain what exactly this class is supposed to do, consider the following mover hierarchy (which comes from the loop modeling framework and was the actual motivation for this code): 

                 A                         ~
                 |                         ~
  +-------+------+------+------+           ~
  |       |      |      |      |           ~
  B       C      D      E      F           ~
         / \    / \           / \          ~
        G   H  I   J         K   L         ~
               |   |        /   /|\        ~
               M   N       O   P Q R       ~
To explain this diagram a little, each letter corresponds to a mover. The movers are mostly of different classes, although they all inherit from the same abstract base class. This whole hierarchy is constructed by A. When A.apply() is called, it calls B.apply(), C.apply(), D.apply(), E.apply(), and F.apply() in that order. When B.apply() is called, it calls G.apply() and H.apply(), and so on. If you are interested in seeing exactly how this hierarchy is implemented, here are the classes the letters correspond to: A. protocols::loop_modeling::LoopModeler B. protocols::loop_modeling::utilities::PrepareForCentroid C. protocols::loop_modeling::LoopBuilder D. protocols::loop_modeling::LoopProtocol E. protocols::loop_modeling::utilities::PrepareForFullatom F. protocols::loop_modeling::LoopProtocol G. protocols::kinematic_closure::KicMover H. protocols::loop_modeling::refiners::MinimizationRefiner I. protocols::loop_modeling::utilities::LoopMoverGroup J. protocols::loop_modeling::utilities::LoopMoverGroup K. protocols::loop_modeling::utilities::LoopMoverGroup L. protocols::loop_modeling::utilities::LoopMoverGroup M. protocols::kinematic_closure::KicMover N. protocols::loop_modeling::refiners::MinimizationRefiner O. protocols::kinematic_closure::KicMover P. protocols::loop_modeling::refiners::RepackingRefiner Q. protocols::loop_modeling::refiners::RotamerTrialsRefiner R. protocols::loop_modeling::refiners::MinimizationRefiner This hierarchy had the following shared data requirements: 1. Everything in the hierarchy has to share a loops object. 2. A has to know about centroid and fullatom score functions. 3. B, D, and all their children have to use the centroid score function. 4. F and all its children have to use the fullatom score function. 5. A has to provide a default task factory to all its children. 6. Only P and Q have any use for a task factory, and they may want to override the default provided by A. Many of these requirements have a similar form: movers higher in the hierarchy must be able to provide default attributes to all their children, and movers lower in the hierarchy must be able to override those defaults. This class supports that pattern by being a data map that asks its parent for missing values. More specifically, this class stores two pieces of information: a DataMap and a pointer to a parent HierarchicalDataMap. The DataMap provides the basic attribute lookup capability: it's just a string to owning pointer map. The parent pointer allows the HierarchicalDataMap to recursively access default values from parent maps for key that aren't in it's own DataMap. Going back to the example hierarchy above: A needs to provide a default task factory that P and Q can override. To accomplish this, we start by giving all the objects in the hierarchy HierarchicalDataMap objects that have been properly connected to their parents. Then A sets the default "task_ops" attribute in it's own HierarchicalDataMap as soon as it's constructed. P and Q provide convenience methods like get_task_ops() and set_task_ops() to allow the "task_ops" field of their HierarchicalDataMaps to be accessed publicly. Since the data maps in P and Q are connected to A via L and F, the attributes stored in A will serve as defaults for P and Q. It's worth noting that in this example, it is also possible to get the right behavior by putting a task operations data member in the shared base class. However, this is a poor solution for two reasons. The first is that it requires many classes that have no need for task operations to have a task operations attribute. Second, it requires that you write the default logic for each attribute that needs it, which is a duplication of effort. Using HierarchicalDataMap addresses both of these problems. When using this class to help build a hierarchy like the one illustrated above, you might find it useful to move public accessor methods (like get_task_ops() and set_task_ops() in P and Q) into a reusable mixin class. This takes a little bit of C++ template magic, because you have to use the "curiously recurring template pattern" (CRTP). But you can see how this works by looking at protocols::loop_modeling::RepackingLoopMover (P in the example) and protocols::loop_modeling::utilites::TaskFactoryMixin (the mixin class).

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (HierarchicalDataMap)) -> None : A data map designed to help create hierarchies with complicated shared data requirements. To explain what exactly this class is supposed to do, consider the following mover hierarchy (which comes from the loop modeling framework and was the actual motivation for this code): 

                     A                         ~
                     |                         ~
      +-------+------+------+------+           ~
      |       |      |      |      |           ~
      B       C      D      E      F           ~
             / \    / \           / \          ~
            G   H  I   J         K   L         ~
                   |   |        /   /|\        ~
                   M   N       O   P Q R       ~
To explain this diagram a little, each letter corresponds to a mover. The movers are mostly of different classes, although they all inherit from the same abstract base class. This whole hierarchy is constructed by A. When A.apply() is called, it calls B.apply(), C.apply(), D.apply(), E.apply(), and F.apply() in that order. When B.apply() is called, it calls G.apply() and H.apply(), and so on. If you are interested in seeing exactly how this hierarchy is implemented, here are the classes the letters correspond to: A. protocols::loop_modeling::LoopModeler B. protocols::loop_modeling::utilities::PrepareForCentroid C. protocols::loop_modeling::LoopBuilder D. protocols::loop_modeling::LoopProtocol E. protocols::loop_modeling::utilities::PrepareForFullatom F. protocols::loop_modeling::LoopProtocol G. protocols::kinematic_closure::KicMover H. protocols::loop_modeling::refiners::MinimizationRefiner I. protocols::loop_modeling::utilities::LoopMoverGroup J. protocols::loop_modeling::utilities::LoopMoverGroup K. protocols::loop_modeling::utilities::LoopMoverGroup L. protocols::loop_modeling::utilities::LoopMoverGroup M. protocols::kinematic_closure::KicMover N. protocols::loop_modeling::refiners::MinimizationRefiner O. protocols::kinematic_closure::KicMover P. protocols::loop_modeling::refiners::RepackingRefiner Q. protocols::loop_modeling::refiners::RotamerTrialsRefiner R. protocols::loop_modeling::refiners::MinimizationRefiner This hierarchy had the following shared data requirements: 1. Everything in the hierarchy has to share a loops object. 2. A has to know about centroid and fullatom score functions. 3. B, D, and all their children have to use the centroid score function. 4. F and all its children have to use the fullatom score function. 5. A has to provide a default task factory to all its children. 6. Only P and Q have any use for a task factory, and they may want to override the default provided by A. Many of these requirements have a similar form: movers higher in the hierarchy must be able to provide default attributes to all their children, and movers lower in the hierarchy must be able to override those defaults. This class supports that pattern by being a data map that asks its parent for missing values. More specifically, this class stores two pieces of information: a DataMap and a pointer to a parent HierarchicalDataMap. The DataMap provides the basic attribute lookup capability: it's just a string to owning pointer map. The parent pointer allows the HierarchicalDataMap to recursively access default values from parent maps for key that aren't in it's own DataMap. Going back to the example hierarchy above: A needs to provide a default task factory that P and Q can override. To accomplish this, we start by giving all the objects in the hierarchy HierarchicalDataMap objects that have been properly connected to their parents. Then A sets the default "task_ops" attribute in it's own HierarchicalDataMap as soon as it's constructed. P and Q provide convenience methods like get_task_ops() and set_task_ops() to allow the "task_ops" field of their HierarchicalDataMaps to be accessed publicly. Since the data maps in P and Q are connected to A via L and F, the attributes stored in A will serve as defaults for P and Q. It's worth noting that in this example, it is also possible to get the right behavior by putting a task operations data member in the shared base class. However, this is a poor solution for two reasons. The first is that it requires many classes that have no need for task operations to have a task operations attribute. Second, it requires that you write the default logic for each attribute that needs it, which is a duplication of effort. Using HierarchicalDataMap addresses both of these problems. When using this class to help build a hierarchy like the one illustrated above, you might find it useful to move public accessor methods (like get_task_ops() and set_task_ops() in P and Q) into a reusable mixin class. This takes a little bit of C++ template magic, because you have to use the "curiously recurring template pattern" (CRTP). But you can see how this works by looking at protocols::loop_modeling::RepackingLoopMover (P in the example) and protocols::loop_modeling::utilites::TaskFactoryMixin (the mixin class).

C++ signature :
    void __init__(_object*,basic::datacache::HierarchicalDataMap)

def set_parent(

...)

set_parent( (HierarchicalDataMap)arg1, (HierarchicalDataMapCAP)parent) -> None : Set a parent for this data map. If a key is requested and not found in this data map, the search will continue (recursively) in the parent. Having a parent is optional.

C++ signature : void set_parent(basic::datacache::HierarchicalDataMap {lvalue},boost::weak_ptr)

def unset_parent(

...)

unset_parent( (HierarchicalDataMap)arg1) -> None : Unset the parent for this data map. When a data map doesn't have a parent, it will only return keys it is holding itself. Having a parent is optional.

C++ signature : void unset_parent(basic::datacache::HierarchicalDataMap {lvalue})

class HierarchicalDataMapAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (HierarchicalDataMapAP)arg1) -> HierarchicalDataMap :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class HierarchicalDataMapCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (HierarchicalDataMapCAP)arg1) -> HierarchicalDataMap :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class SingletonBase_T_basic_datacache_WriteableCacheableDataFactory_T

SingletonBase is meant to serve as a base class for singleton classes in Rosetta handling the initialization of the singleton in a thread-safe way. The derived class must a) implement a private, static function: T * create_singleton_instance() so that the SingletonBase class can invoke this function, and b) declare the SingletonBase class to be a friend, so that it can invoke this function The .cc file in which the derived singleton must be put will need to include the definitions for the two static data members, instance_ and singleton_mutex_.

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

class SingletonBase_T_basic_datacache_WriteableCacheableDataFactory_TAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SingletonBase_T_basic_datacache_WriteableCacheableDataFactory_TAP)arg1) -> SingletonBase_T_basic_datacache_WriteableCacheableDataFactory_T :

C++ signature : boost::shared_ptr > get(boost::weak_ptr >)

class SingletonBase_T_basic_datacache_WriteableCacheableDataFactory_TCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (SingletonBase_T_basic_datacache_WriteableCacheableDataFactory_TCAP)arg1) -> SingletonBase_T_basic_datacache_WriteableCacheableDataFactory_T :

C++ signature : boost::shared_ptr const> get(boost::weak_ptr const>)

class WriteableCacheableData

base class for data storable within a DataCache

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: CacheableData.__init__

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def clone(

...)

Inheritance: CacheableData.clone

clone( (WriteableCacheableData)arg1) -> CacheableData : basic/datacache/CacheableData.hh:54

C++ signature :
    boost::shared_ptr<basic::datacache::CacheableData> clone(basic::datacache::WriteableCacheableData {lvalue})

clone( (WriteableCacheableData)arg1) -> None :

C++ signature :
    void clone(boost::shared_ptr<WriteableCacheableData_exposer_callback> {lvalue})

def datatype(

...)

datatype( (WriteableCacheableData)arg1) -> str : basic/datacache/WriteableCacheableData.hh:56

C++ signature :
    std::string datatype(basic::datacache::WriteableCacheableData {lvalue})

datatype( (WriteableCacheableData)arg1) -> None :

C++ signature :
    void datatype(boost::shared_ptr<WriteableCacheableData_exposer_callback> {lvalue})

def get_self_ptr(

...)

Inheritance: CacheableData.get_self_ptr

get_self_ptr( (CacheableData)arg1) -> CacheableData : self pointers

C++ signature :
    boost::shared_ptr<basic::datacache::CacheableData const> get_self_ptr(basic::datacache::CacheableData {lvalue})

get_self_ptr( (CacheableData)arg1) -> CacheableData : basic/datacache/CacheableData.hh:47

C++ signature :
    boost::shared_ptr<basic::datacache::CacheableData> get_self_ptr(basic::datacache::CacheableData {lvalue})

def get_self_weak_ptr(

...)

Inheritance: CacheableData.get_self_weak_ptr

get_self_weak_ptr( (CacheableData)arg1) -> CacheableDataCAP : basic/datacache/CacheableData.hh:48

C++ signature :
    boost::weak_ptr<basic::datacache::CacheableData const> get_self_weak_ptr(basic::datacache::CacheableData {lvalue})

get_self_weak_ptr( (CacheableData)arg1) -> CacheableDataAP : basic/datacache/CacheableData.hh:49

C++ signature :
    boost::weak_ptr<basic::datacache::CacheableData> get_self_weak_ptr(basic::datacache::CacheableData {lvalue})

def write(

...)

write( (WriteableCacheableData)arg1, (OStream)out) -> None : basic/datacache/WriteableCacheableData.hh:53

C++ signature :
    void write(basic::datacache::WriteableCacheableData {lvalue},std::ostream {lvalue})

write( (WriteableCacheableData)arg1, (OStream)arg2) -> None :

C++ signature :
    void write(boost::shared_ptr<WriteableCacheableData_exposer_callback> {lvalue},std::ostream {lvalue})

class WriteableCacheableDataAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (WriteableCacheableDataAP)arg1) -> WriteableCacheableData :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class WriteableCacheableDataCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (WriteableCacheableDataCAP)arg1) -> WriteableCacheableData :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class WriteableCacheableDataCreator

Abstract base class for a Mover factory; the Creator class is responsible for creating a particular mover class.

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def create_data(

...)

create_data( (WriteableCacheableDataCreator)arg1, (std_istream)in) -> WriteableCacheableData : basic/datacache/WriteableCacheableDataCreator.hh:37

C++ signature :
    boost::shared_ptr<basic::datacache::WriteableCacheableData> create_data(basic::datacache::WriteableCacheableDataCreator {lvalue},std::istream {lvalue})

create_data( (WriteableCacheableDataCreator)arg1, (std_istream)arg2) -> None :

C++ signature :
    void create_data(boost::shared_ptr<WriteableCacheableDataCreator_exposer_callback> {lvalue},std::istream {lvalue})

def keyname(

...)

keyname( (WriteableCacheableDataCreator)arg1) -> str : basic/datacache/WriteableCacheableDataCreator.hh:38

C++ signature :
    std::string keyname(basic::datacache::WriteableCacheableDataCreator {lvalue})

keyname( (WriteableCacheableDataCreator)arg1) -> None :

C++ signature :
    void keyname(boost::shared_ptr<WriteableCacheableDataCreator_exposer_callback> {lvalue})

class WriteableCacheableDataCreatorAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (WriteableCacheableDataCreatorAP)arg1) -> WriteableCacheableDataCreator :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class WriteableCacheableDataCreatorCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (WriteableCacheableDataCreatorCAP)arg1) -> WriteableCacheableDataCreator :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class WriteableCacheableDataFactory

basic/datacache/WriteableCacheableDataFactory.hh:52

Ancestors (in MRO)

Methods

def factory_register(

...)

factory_register( (WriteableCacheableDataFactory)arg1, (CPP_WriteableCacheableDataCreator)creator) -> None : basic/datacache/WriteableCacheableDataFactory.hh:61

C++ signature : void factory_register(basic::datacache::WriteableCacheableDataFactory {lvalue},boost::shared_ptr)

def new_data_instance(

...)

new_data_instance( (WriteableCacheableDataFactory)arg1, (str)data_type_name, (std_istream)in) -> WriteableCacheableData : Create a data instance given its identifying string

C++ signature : boost::shared_ptr new_data_instance(basic::datacache::WriteableCacheableDataFactory {lvalue},std::string,std::istream {lvalue})

class WriteableCacheableDataFactoryAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (WriteableCacheableDataFactoryAP)arg1) -> WriteableCacheableDataFactory :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class WriteableCacheableDataFactoryCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (WriteableCacheableDataFactoryCAP)arg1) -> WriteableCacheableDataFactory :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class WriteableCacheableMap

Wrapper for a map< string, string >.

Ancestors (in MRO)

Methods

def __init__(

...)

Inheritance: CacheableData.__init__

init( (object)arg1) -> None :

C++ signature :
    void __init__(_object*)

init( (object)arg1, (WriteableCacheableMap)other) -> None : basic/datacache/WriteableCacheableMap.hh:56

C++ signature :
    void __init__(_object*,basic::datacache::WriteableCacheableMap)

def begin(

...)

begin( (WriteableCacheableMap)arg1) -> object : basic/datacache/WriteableCacheableMap.hh:81

C++ signature :
    std::_Rb_tree_const_iterator<std::pair<std::string const, std::set<boost::shared_ptr<basic::datacache::WriteableCacheableData>, std::less<boost::shared_ptr<basic::datacache::WriteableCacheableData> >, std::allocator<boost::shared_ptr<basic::datacache::WriteableCacheableData> > > > > begin(basic::datacache::WriteableCacheableMap {lvalue})

begin( (WriteableCacheableMap)arg1) -> object :

C++ signature :
    std::_Rb_tree_const_iterator<std::pair<std::string const, std::set<boost::shared_ptr<basic::datacache::WriteableCacheableData>, std::less<boost::shared_ptr<basic::datacache::WriteableCacheableData> >, std::allocator<boost::shared_ptr<basic::datacache::WriteableCacheableData> > > > > begin(WriteableCacheableMap_exposer_callback {lvalue})

def clone(

...)

Inheritance: CacheableData.clone

clone( (WriteableCacheableMap)arg1) -> CacheableData : basic/datacache/WriteableCacheableMap.hh:62

C++ signature :
    boost::shared_ptr<basic::datacache::CacheableData> clone(basic::datacache::WriteableCacheableMap {lvalue})

clone( (WriteableCacheableMap)arg1) -> CacheableData :

C++ signature :
    boost::shared_ptr<basic::datacache::CacheableData> clone(WriteableCacheableMap_exposer_callback {lvalue})

def end(

...)

end( (WriteableCacheableMap)arg1) -> object : basic/datacache/WriteableCacheableMap.hh:85

C++ signature :
    std::_Rb_tree_const_iterator<std::pair<std::string const, std::set<boost::shared_ptr<basic::datacache::WriteableCacheableData>, std::less<boost::shared_ptr<basic::datacache::WriteableCacheableData> >, std::allocator<boost::shared_ptr<basic::datacache::WriteableCacheableData> > > > > end(basic::datacache::WriteableCacheableMap {lvalue})

end( (WriteableCacheableMap)arg1) -> object :

C++ signature :
    std::_Rb_tree_const_iterator<std::pair<std::string const, std::set<boost::shared_ptr<basic::datacache::WriteableCacheableData>, std::less<boost::shared_ptr<basic::datacache::WriteableCacheableData> >, std::allocator<boost::shared_ptr<basic::datacache::WriteableCacheableData> > > > > end(WriteableCacheableMap_exposer_callback {lvalue})

def erase(

...)

erase( (WriteableCacheableMap)arg1, (CPP_WriteableCacheableData)d) -> None : basic/datacache/WriteableCacheableMap.hh:74

C++ signature :
    void erase(basic::datacache::WriteableCacheableMap {lvalue},boost::shared_ptr<basic::datacache::WriteableCacheableData>)

erase( (WriteableCacheableMap)arg1, (CPP_WriteableCacheableData)d) -> None :

C++ signature :
    void erase(WriteableCacheableMap_exposer_callback {lvalue},boost::shared_ptr<basic::datacache::WriteableCacheableData>)

def find(

...)

find( (WriteableCacheableMap)arg1, (str)str) -> object : basic/datacache/WriteableCacheableMap.hh:93

C++ signature :
    std::_Rb_tree_const_iterator<std::pair<std::string const, std::set<boost::shared_ptr<basic::datacache::WriteableCacheableData>, std::less<boost::shared_ptr<basic::datacache::WriteableCacheableData> >, std::allocator<boost::shared_ptr<basic::datacache::WriteableCacheableData> > > > > find(basic::datacache::WriteableCacheableMap {lvalue},std::string)

find( (WriteableCacheableMap)arg1, (str)str) -> object :

C++ signature :
    std::_Rb_tree_const_iterator<std::pair<std::string const, std::set<boost::shared_ptr<basic::datacache::WriteableCacheableData>, std::less<boost::shared_ptr<basic::datacache::WriteableCacheableData> >, std::allocator<boost::shared_ptr<basic::datacache::WriteableCacheableData> > > > > find(WriteableCacheableMap_exposer_callback {lvalue},std::string)

def get_self_ptr(

...)

Inheritance: CacheableData.get_self_ptr

get_self_ptr( (CacheableData)arg1) -> CacheableData : self pointers

C++ signature :
    boost::shared_ptr<basic::datacache::CacheableData const> get_self_ptr(basic::datacache::CacheableData {lvalue})

get_self_ptr( (CacheableData)arg1) -> CacheableData : basic/datacache/CacheableData.hh:47

C++ signature :
    boost::shared_ptr<basic::datacache::CacheableData> get_self_ptr(basic::datacache::CacheableData {lvalue})

def get_self_weak_ptr(

...)

Inheritance: CacheableData.get_self_weak_ptr

get_self_weak_ptr( (CacheableData)arg1) -> CacheableDataCAP : basic/datacache/CacheableData.hh:48

C++ signature :
    boost::weak_ptr<basic::datacache::CacheableData const> get_self_weak_ptr(basic::datacache::CacheableData {lvalue})

get_self_weak_ptr( (CacheableData)arg1) -> CacheableDataAP : basic/datacache/CacheableData.hh:49

C++ signature :
    boost::weak_ptr<basic::datacache::CacheableData> get_self_weak_ptr(basic::datacache::CacheableData {lvalue})

def has(

...)

has( (WriteableCacheableMap)arg1, (CPP_WriteableCacheableData)data) -> bool : basic/datacache/WriteableCacheableMap.hh:97

C++ signature :
    bool has(basic::datacache::WriteableCacheableMap {lvalue},boost::shared_ptr<basic::datacache::WriteableCacheableData>)

has( (WriteableCacheableMap)arg1, (CPP_WriteableCacheableData)data) -> bool :

C++ signature :
    bool has(WriteableCacheableMap_exposer_callback {lvalue},boost::shared_ptr<basic::datacache::WriteableCacheableData>)

def insert(

...)

insert( (WriteableCacheableMap)arg1, (CPP_WriteableCacheableData)data) -> None : basic/datacache/WriteableCacheableMap.hh:104

C++ signature :
    void insert(basic::datacache::WriteableCacheableMap {lvalue},boost::shared_ptr<basic::datacache::WriteableCacheableData>)

insert( (WriteableCacheableMap)arg1, (CPP_WriteableCacheableData)data) -> None :

C++ signature :
    void insert(WriteableCacheableMap_exposer_callback {lvalue},boost::shared_ptr<basic::datacache::WriteableCacheableData>)

def map(

...)

map( (WriteableCacheableMap)arg1) -> object : basic/datacache/WriteableCacheableMap.hh:66

C++ signature :
    std::map<std::string, std::set<boost::shared_ptr<basic::datacache::WriteableCacheableData>, std::less<boost::shared_ptr<basic::datacache::WriteableCacheableData> >, std::allocator<boost::shared_ptr<basic::datacache::WriteableCacheableData> > >, std::less<std::string>, std::allocator<std::pair<std::string const, std::set<boost::shared_ptr<basic::datacache::WriteableCacheableData>, std::less<boost::shared_ptr<basic::datacache::WriteableCacheableData> >, std::allocator<boost::shared_ptr<basic::datacache::WriteableCacheableData> > > > > > {lvalue} map(basic::datacache::WriteableCacheableMap {lvalue})

map( (WriteableCacheableMap)arg1) -> object :

C++ signature :
    std::map<std::string, std::set<boost::shared_ptr<basic::datacache::WriteableCacheableData>, std::less<boost::shared_ptr<basic::datacache::WriteableCacheableData> >, std::allocator<boost::shared_ptr<basic::datacache::WriteableCacheableData> > >, std::less<std::string>, std::allocator<std::pair<std::string const, std::set<boost::shared_ptr<basic::datacache::WriteableCacheableData>, std::less<boost::shared_ptr<basic::datacache::WriteableCacheableData> >, std::allocator<boost::shared_ptr<basic::datacache::WriteableCacheableData> > > > > > {lvalue} map(WriteableCacheableMap_exposer_callback {lvalue})

map( (WriteableCacheableMap)arg1) -> object : basic/datacache/WriteableCacheableMap.hh:70

C++ signature :
    std::map<std::string, std::set<boost::shared_ptr<basic::datacache::WriteableCacheableData>, std::less<boost::shared_ptr<basic::datacache::WriteableCacheableData> >, std::allocator<boost::shared_ptr<basic::datacache::WriteableCacheableData> > >, std::less<std::string>, std::allocator<std::pair<std::string const, std::set<boost::shared_ptr<basic::datacache::WriteableCacheableData>, std::less<boost::shared_ptr<basic::datacache::WriteableCacheableData> >, std::allocator<boost::shared_ptr<basic::datacache::WriteableCacheableData> > > > > > map(basic::datacache::WriteableCacheableMap {lvalue})

class WriteableCacheableMapAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (WriteableCacheableMapAP)arg1) -> WriteableCacheableMap :

C++ signature : boost::shared_ptr get(boost::weak_ptr)

class WriteableCacheableMapCAP

Ancestors (in MRO)

Methods

def __init__(

...)

init( (object)arg1) -> None :

C++ signature : void init(_object*)

def get(

...)

get( (WriteableCacheableMapCAP)arg1) -> WriteableCacheableMap :

C++ signature : boost::shared_ptr get(boost::weak_ptr)