| | |
- builtins.object
-
- CacheableData
-
- CacheableString
- CacheableStringFloatMap
- CacheableStringMap
- DiagnosticData
- WriteableCacheableData
- WriteableCacheableMap
- ConstDataMap
- DataCache_basic_datacache_CacheableData_t
-
- BasicDataCache
- DataCache_CacheableData
- DataCache_core_pose_datacache_CacheableObserver_t
- DataMap
- HierarchicalDataMap
- WriteableCacheableDataCreator
- rosetta.utility.SingletonBase_basic_datacache_WriteableCacheableDataFactory_t(builtins.object)
-
- WriteableCacheableDataFactory
class BasicDataCache(DataCache_basic_datacache_CacheableData_t) |
| |
A DataCache storing objects derived from
basic::datacache::CacheableData.
See DataCache base class for usage details.
|
| |
- Method resolution order:
- BasicDataCache
- DataCache_basic_datacache_CacheableData_t
- builtins.object
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(rosetta.basic.datacache.BasicDataCache) -> NoneType
2. __init__(self : rosetta.basic.datacache.BasicDataCache, n_slots : int) -> NoneType
3. __init__(self : rosetta.basic.datacache.BasicDataCache, rval : rosetta.basic.datacache.BasicDataCache) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.basic.datacache.BasicDataCache, rval : rosetta.basic.datacache.BasicDataCache) -> rosetta.basic.datacache.BasicDataCache
copy assignment
Methods inherited from DataCache_basic_datacache_CacheableData_t:
- clear(...) from builtins.PyCapsule
- clear(*args, **kwargs)
Overloaded function.
1. clear(rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t) -> NoneType
2. clear(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot : int) -> NoneType
- get(...) from builtins.PyCapsule
- get(*args, **kwargs)
Overloaded function.
1. get(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot : int) -> basic::datacache::CacheableData
2. get(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot : int) -> basic::datacache::CacheableData
- get_const_ptr(...) from builtins.PyCapsule
- get_const_ptr(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot : int) -> basic::datacache::CacheableData
- get_ptr(...) from builtins.PyCapsule
- get_ptr(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot : int) -> basic::datacache::CacheableData
- get_raw_const_ptr(...) from builtins.PyCapsule
- get_raw_const_ptr(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot : int) -> basic::datacache::CacheableData
- get_raw_ptr(...) from builtins.PyCapsule
- get_raw_ptr(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot : int) -> basic::datacache::CacheableData
- has(...) from builtins.PyCapsule
- has(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot : int) -> bool
- resize(...) from builtins.PyCapsule
- resize(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, n_slots : int) -> NoneType
- set(...) from builtins.PyCapsule
- set(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot : int, new_data : basic::datacache::CacheableData) -> NoneType
- size(...) from builtins.PyCapsule
- size(rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t) -> int
|
class ConstDataMap(builtins.object) |
| |
general-purpose store for any kind of object with the particular
copy semantics of copying by value. This is effectively a map of
string pairs to (constant) pointers. The first string represents the
category of the object, and the second being a name for that particular
object. The guarantee with the ConstDataMap is that if an object is put
into the map, it may be read from, but it will not be changed underneath
you. Data stored in the ConstDataMap can safely be shared between threads.
|
| |
Methods defined here:
- __eq__(...) from builtins.PyCapsule
- __eq__(self : rosetta.basic.datacache.ConstDataMap, rhs : rosetta.basic.datacache.ConstDataMap) -> bool
Performs pointer comparison to determine if these two maps point at the same data.
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(rosetta.basic.datacache.ConstDataMap) -> NoneType
2. __init__(self : rosetta.basic.datacache.ConstDataMap, src : rosetta.basic.datacache.ConstDataMap) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.basic.datacache.ConstDataMap, rhs : rosetta.basic.datacache.ConstDataMap) -> rosetta.basic.datacache.ConstDataMap
Performs a shallow copy of all of the pointers stored in rhs into this.
- has(...) from builtins.PyCapsule
- has(*args, **kwargs)
Overloaded function.
1. has(self : rosetta.basic.datacache.ConstDataMap, category : str) -> bool
are there any objects in the outer map with the given category?
2. has(self : rosetta.basic.datacache.ConstDataMap, category : str, name : str) -> bool
Is there an object with the given category and the given name?
- size(...) from builtins.PyCapsule
- size(rosetta.basic.datacache.ConstDataMap) -> int
returns the number of objects contained in the map
|
class DataCache_CacheableData(DataCache_basic_datacache_CacheableData_t) |
| | |
- Method resolution order:
- DataCache_CacheableData
- DataCache_basic_datacache_CacheableData_t
- builtins.object
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(rosetta.basic.datacache.DataCache_CacheableData) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.basic.datacache.DataCache_CacheableData, : rosetta.basic.datacache.DataCache_CacheableData) -> rosetta.basic.datacache.DataCache_CacheableData
Methods inherited from DataCache_basic_datacache_CacheableData_t:
- clear(...) from builtins.PyCapsule
- clear(*args, **kwargs)
Overloaded function.
1. clear(rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t) -> NoneType
2. clear(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot : int) -> NoneType
- get(...) from builtins.PyCapsule
- get(*args, **kwargs)
Overloaded function.
1. get(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot : int) -> basic::datacache::CacheableData
2. get(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot : int) -> basic::datacache::CacheableData
- get_const_ptr(...) from builtins.PyCapsule
- get_const_ptr(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot : int) -> basic::datacache::CacheableData
- get_ptr(...) from builtins.PyCapsule
- get_ptr(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot : int) -> basic::datacache::CacheableData
- get_raw_const_ptr(...) from builtins.PyCapsule
- get_raw_const_ptr(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot : int) -> basic::datacache::CacheableData
- get_raw_ptr(...) from builtins.PyCapsule
- get_raw_ptr(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot : int) -> basic::datacache::CacheableData
- has(...) from builtins.PyCapsule
- has(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot : int) -> bool
- resize(...) from builtins.PyCapsule
- resize(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, n_slots : int) -> NoneType
- set(...) from builtins.PyCapsule
- set(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot : int, new_data : basic::datacache::CacheableData) -> NoneType
- size(...) from builtins.PyCapsule
- size(rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t) -> int
|
class DataCache_basic_datacache_CacheableData_t(builtins.object) |
| | |
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t) -> NoneType
2. __init__(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, n_slots : int) -> NoneType
3. __init__(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, src : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, src : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t) -> rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t
- clear(...) from builtins.PyCapsule
- clear(*args, **kwargs)
Overloaded function.
1. clear(rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t) -> NoneType
2. clear(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot : int) -> NoneType
- get(...) from builtins.PyCapsule
- get(*args, **kwargs)
Overloaded function.
1. get(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot : int) -> basic::datacache::CacheableData
2. get(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot : int) -> basic::datacache::CacheableData
- get_const_ptr(...) from builtins.PyCapsule
- get_const_ptr(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot : int) -> basic::datacache::CacheableData
- get_ptr(...) from builtins.PyCapsule
- get_ptr(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot : int) -> basic::datacache::CacheableData
- get_raw_const_ptr(...) from builtins.PyCapsule
- get_raw_const_ptr(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot : int) -> basic::datacache::CacheableData
- get_raw_ptr(...) from builtins.PyCapsule
- get_raw_ptr(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot : int) -> basic::datacache::CacheableData
- has(...) from builtins.PyCapsule
- has(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot : int) -> bool
- resize(...) from builtins.PyCapsule
- resize(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, n_slots : int) -> NoneType
- set(...) from builtins.PyCapsule
- set(self : rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t, slot : int, new_data : basic::datacache::CacheableData) -> NoneType
- size(...) from builtins.PyCapsule
- size(rosetta.basic.datacache.DataCache_basic_datacache_CacheableData_t) -> int
|
class DataCache_core_pose_datacache_CacheableObserver_t(builtins.object) |
| | |
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t) -> NoneType
2. __init__(self : rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t, n_slots : int) -> NoneType
3. __init__(self : rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t, src : rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t, src : rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t) -> rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t
- clear(...) from builtins.PyCapsule
- clear(*args, **kwargs)
Overloaded function.
1. clear(rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t) -> NoneType
2. clear(self : rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t, slot : int) -> NoneType
- get(...) from builtins.PyCapsule
- get(*args, **kwargs)
Overloaded function.
1. get(self : rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t, slot : int) -> core::pose::datacache::CacheableObserver
2. get(self : rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t, slot : int) -> core::pose::datacache::CacheableObserver
- get_const_ptr(...) from builtins.PyCapsule
- get_const_ptr(self : rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t, slot : int) -> core::pose::datacache::CacheableObserver
- get_ptr(...) from builtins.PyCapsule
- get_ptr(self : rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t, slot : int) -> core::pose::datacache::CacheableObserver
- get_raw_const_ptr(...) from builtins.PyCapsule
- get_raw_const_ptr(self : rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t, slot : int) -> core::pose::datacache::CacheableObserver
- get_raw_ptr(...) from builtins.PyCapsule
- get_raw_ptr(self : rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t, slot : int) -> core::pose::datacache::CacheableObserver
- has(...) from builtins.PyCapsule
- has(self : rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t, slot : int) -> bool
- resize(...) from builtins.PyCapsule
- resize(self : rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t, n_slots : int) -> NoneType
- set(...) from builtins.PyCapsule
- set(self : rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t, slot : int, new_data : core::pose::datacache::CacheableObserver) -> NoneType
- size(...) from builtins.PyCapsule
- size(rosetta.basic.datacache.DataCache_core_pose_datacache_CacheableObserver_t) -> int
|
class DataMap(builtins.object) |
| |
general-purpose store for any reference-count derived object
|
| |
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(rosetta.basic.datacache.DataMap) -> NoneType
2. __init__(self : rosetta.basic.datacache.DataMap, : rosetta.basic.datacache.DataMap) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.basic.datacache.DataMap, : rosetta.basic.datacache.DataMap) -> rosetta.basic.datacache.DataMap
- has(...) from builtins.PyCapsule
- has(*args, **kwargs)
Overloaded function.
1. has(self : rosetta.basic.datacache.DataMap, type : str) -> bool
Does the data map contain an entry with a specific name in the given type?
calling this function without providing a name is just plain wrong and makes no sense
and I would be changing that right now if Kale hadn't already found out that some code
relies on this bad behavior back in pull request #187
2. has(self : rosetta.basic.datacache.DataMap, type : str, name : str) -> bool
Does the data map contain an entry with a specific name in the given type?
calling this function without providing a name is just plain wrong and makes no sense
and I would be changing that right now if Kale hadn't already found out that some code
relies on this bad behavior back in pull request #187
- has_type(...) from builtins.PyCapsule
- has_type(self : rosetta.basic.datacache.DataMap, type : str) -> bool
Does the data map contain the given type?
- size(...) from builtins.PyCapsule
- size(rosetta.basic.datacache.DataMap) -> int
returns the size of the map (how many different types are in data_map_
|
class HierarchicalDataMap(builtins.object) |
| |
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).
|
| |
Methods defined here:
- __init__(...) from builtins.PyCapsule
- __init__(rosetta.basic.datacache.HierarchicalDataMap) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.basic.datacache.HierarchicalDataMap, : rosetta.basic.datacache.HierarchicalDataMap) -> rosetta.basic.datacache.HierarchicalDataMap
- set_parent(...) from builtins.PyCapsule
- set_parent(self : rosetta.basic.datacache.HierarchicalDataMap, parent : rosetta.std.weak_ptr_const_basic_datacache_HierarchicalDataMap_t) -> NoneType
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.
- unset_parent(...) from builtins.PyCapsule
- unset_parent(rosetta.basic.datacache.HierarchicalDataMap) -> NoneType
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.
|
class WriteableCacheableMap(CacheableData) |
| |
Wrapper for a map< string, string >.
|
| |
- Method resolution order:
- WriteableCacheableMap
- CacheableData
- builtins.object
Methods defined here:
- __getitem__(...) from builtins.PyCapsule
- __getitem__(self : rosetta.basic.datacache.WriteableCacheableMap, str : str) -> rosetta.std.set_std_shared_ptr_basic_datacache_WriteableCacheableData_std_less_std_shared_ptr_basic_datacache_WriteableCacheableData_std_allocator_std_shared_ptr_basic_datacache_WriteableCacheableData_t
- __init__(...) from builtins.PyCapsule
- __init__(*args, **kwargs)
Overloaded function.
1. __init__(handle) -> NoneType
2. __init__(handle, rosetta.basic.datacache.WriteableCacheableMap) -> NoneType
- __new__(*args, **kwargs) from builtins.type
- Create and return a new object. See help(type) for accurate signature.
- assign(...) from builtins.PyCapsule
- assign(self : rosetta.basic.datacache.WriteableCacheableMap, : rosetta.basic.datacache.WriteableCacheableMap) -> rosetta.basic.datacache.WriteableCacheableMap
- begin(...) from builtins.PyCapsule
- begin(rosetta.basic.datacache.WriteableCacheableMap) -> std::_Rb_tree_const_iterator<std::pair<std::string const, std::set<std::shared_ptr<basic::datacache::WriteableCacheableData>, std::less<std::shared_ptr<basic::datacache::WriteableCacheableData> >, std::allocator<std::shared_ptr<basic::datacache::WriteableCacheableData> > > > >
- clone(...) from builtins.PyCapsule
- clone(rosetta.basic.datacache.WriteableCacheableMap) -> rosetta.basic.datacache.CacheableData
- end(...) from builtins.PyCapsule
- end(rosetta.basic.datacache.WriteableCacheableMap) -> std::_Rb_tree_const_iterator<std::pair<std::string const, std::set<std::shared_ptr<basic::datacache::WriteableCacheableData>, std::less<std::shared_ptr<basic::datacache::WriteableCacheableData> >, std::allocator<std::shared_ptr<basic::datacache::WriteableCacheableData> > > > >
- erase(...) from builtins.PyCapsule
- erase(self : rosetta.basic.datacache.WriteableCacheableMap, d : rosetta.basic.datacache.WriteableCacheableData) -> NoneType
- find(...) from builtins.PyCapsule
- find(self : rosetta.basic.datacache.WriteableCacheableMap, str : str) -> std::_Rb_tree_const_iterator<std::pair<std::string const, std::set<std::shared_ptr<basic::datacache::WriteableCacheableData>, std::less<std::shared_ptr<basic::datacache::WriteableCacheableData> >, std::allocator<std::shared_ptr<basic::datacache::WriteableCacheableData> > > > >
- has(...) from builtins.PyCapsule
- has(self : rosetta.basic.datacache.WriteableCacheableMap, data : rosetta.basic.datacache.WriteableCacheableData) -> bool
- insert(...) from builtins.PyCapsule
- insert(self : rosetta.basic.datacache.WriteableCacheableMap, data : rosetta.basic.datacache.WriteableCacheableData) -> NoneType
- map(...) from builtins.PyCapsule
- map(*args, **kwargs)
Overloaded function.
1. map(rosetta.basic.datacache.WriteableCacheableMap) -> rosetta.std.map_std_string_std_set_std_shared_ptr_basic_datacache_WriteableCacheableData_std_less_std_shared_ptr_basic_datacache_WriteableCacheableData_std_allocator_std_shared_ptr_basic_datacache_WriteableCacheableData_t
2. map(rosetta.basic.datacache.WriteableCacheableMap) -> rosetta.std.map_std_string_std_set_std_shared_ptr_basic_datacache_WriteableCacheableData_std_less_std_shared_ptr_basic_datacache_WriteableCacheableData_std_allocator_std_shared_ptr_basic_datacache_WriteableCacheableData_t
- shared_from_this(...) from builtins.PyCapsule
- shared_from_this(rosetta.basic.datacache.WriteableCacheableMap) -> rosetta.basic.datacache.WriteableCacheableMap
Methods inherited from CacheableData:
- get_self_ptr(...) from builtins.PyCapsule
- get_self_ptr(*args, **kwargs)
Overloaded function.
1. get_self_ptr(rosetta.basic.datacache.CacheableData) -> rosetta.basic.datacache.CacheableData
self pointers
2. get_self_ptr(rosetta.basic.datacache.CacheableData) -> rosetta.basic.datacache.CacheableData
- get_self_weak_ptr(...) from builtins.PyCapsule
- get_self_weak_ptr(*args, **kwargs)
Overloaded function.
1. get_self_weak_ptr(rosetta.basic.datacache.CacheableData) -> rosetta.std.weak_ptr_const_basic_datacache_CacheableData_t
2. get_self_weak_ptr(rosetta.basic.datacache.CacheableData) -> rosetta.std.weak_ptr_basic_datacache_CacheableData_t
| |