esp::core::managedContainers::ManagedContainerBase class

Base class of Managed Container, holding template-type-independent functionality.

Derived classes

template<class T, ManagedObjectAccess Access>
class ManagedContainer
Class template defining responsibilities and functionality for managing esp::core::AbstractManagedObject constructs.
template<class T, ManagedObjectAccess Access>
class ManagedContainer
Class template defining responsibilities and functionality for managing esp::core::AbstractManagedObject constructs.
template<class T, ManagedObjectAccess Access>
class ManagedContainer
Class template defining responsibilities and functionality for managing esp::core::AbstractManagedObject constructs.
template<class T, ManagedObjectAccess Access>
class ManagedContainer
Class template defining responsibilities and functionality for managing esp::core::AbstractManagedObject constructs.
template<class T, ManagedObjectAccess Access>
class ManagedContainer
Class template defining responsibilities and functionality for managing esp::core::AbstractManagedObject constructs.
template<class T, ManagedObjectAccess Access>
class ManagedContainer
Class template defining responsibilities and functionality for managing esp::core::AbstractManagedObject constructs.
template<class T, ManagedObjectAccess Access>
class ManagedContainer
Class template defining responsibilities and functionality for managing esp::core::AbstractManagedObject constructs.
template<class T, ManagedObjectAccess Access>
class ManagedContainer
Class template defining responsibilities and functionality for managing esp::core::AbstractManagedObject constructs.
template<class T, ManagedObjectAccess Access>
class ManagedContainer
Class template defining responsibilities and functionality for managing esp::core::AbstractManagedObject constructs.
template<class T, ManagedObjectAccess Access>
class ManagedContainer
Class template defining responsibilities and functionality for managing esp::core::AbstractManagedObject constructs.
template<class T, ManagedObjectAccess Access>
class ManagedContainer
Class template defining responsibilities and functionality for managing esp::core::AbstractManagedObject constructs.

Constructors, destructors, conversion operators

ManagedContainerBase(const std::string& metadataType) explicit
~ManagedContainerBase() defaulted virtual

Public functions

auto setLock(const std::string& objectHandle, bool lock) -> bool
Sets/Clears lock state for a managed object, preventing or allowing deletion of managed object.
auto setLockByHandles(const std::vector<std::string>& objectHandles, bool lock) -> std::vector<std::string>
Sets/Clears lock state for a managed object, preventing or allowing deletion of managed object.
auto getObjectIDByHandle(const std::string& objectHandle) -> int
Get the ID of the managed object in ManagedContainerBase::objectLibrary_ for the given managed object Handle, if exists.
auto setLockBySubstring(bool lock, const std::string& subStr = "", bool contains = true) -> std::vector<std::string>
set lock state on all managed objects that contain passed substring.
auto getRandomObjectHandle() const -> std::string
Get the handle for a random managed object registered to this manager.
auto getUniqueHandleFromCandidate(const std::string& name) const -> std::string
return a unique handle given the passed object handle candidate substring. If there are no existing ManagedObjects with the passed handle, then the passed value will be returned; Otherwise, an incremented handle will be returned, based on the names present.
auto getObjectHandlesBySubstring(const std::string& subStr = "", bool contains = true, bool sorted = true) const -> std::vector<std::string>
Get a list of all managed objects handles that contain, or explicitly do not contain subStr, ignoring subStr's case.
auto getUndeletableObjectHandles() const -> std::vector<std::string>
returns a vector of managed object handles representing the system-specified undeletable managed objects this manager manages. These managed objects cannot be deleted, although they can be edited.
auto getIsUndeletable(const std::string& key) const -> bool
Returns whether the object with the passed key is undeletable.
auto getUserLockedObjectHandles() const -> std::vector<std::string>
returns a vector of managed object handles representing managed objects that have been locked by the user. These managed objects cannot be deleted until they have been unlocked, although they can be edited while locked.
auto getIsUserLocked(const std::string& key) const -> bool
Returns whether the object with the passed key is user locked.
void reset()
clears maps of handle-keyed managed object and ID-keyed handles.
auto getObjectHandleByID(const int objectID) const -> std::string
Get the key in objectLibrary_ for the object managed object with the given unique ID.
auto getNumObjects() const -> int
Gets the number of object managed objects stored in the objectLibrary_.
auto getObjectLibHasHandle(const std::string& handle) const -> bool
Checks whether managed object library has passed string handle as key.
auto getObjectLibHasID(int ID) const -> bool
Checks whether managed object library has an object with passed integer as ID.
auto getObjectType() const -> const std::string&
Get the type of object this ManagedContainer manages.
auto getObjectInfoStrings(const std::string& subStr = "", bool contains = true) const -> std::vector<std::string>
Get a vector of strings holding the values of each of the objects this manager manages whose keys match subStr, ignoring subStr's case. Pass an empty string for all objects.
auto getObjectInfoCSVString(const std::string& subStr, bool contains) const -> std::string

Protected functions

auto getObjectIDByHandleOrNew(const std::string& objectHandle, bool getNext) -> int
Used Internally. Get the ID of the managed object in objectLibrary_ for the given managed object Handle, if exists. If the managed object is not in the library and getNext is true then returns next available id, otherwise throws assertion and returns ID_UNDEFINED.
template<class U>
auto getObjectInternal(const std::string& handle) const -> auto
Retrieve shared pointer to object held in library, NOT a copy.
void setObjectInternal(const std::shared_ptr<void>& ptr, const std::string& handle)
Only used from class template AddObject method. put the passed smart poitner in the library.
void deleteObjectInternalFinalize(int objectID, const std::string& objectHandle) pure virtual
This method will perform any necessary updating that is ManagedContainer specialization-specific upon managed object removal, such as removing a specific managed object handle from the list of file-based managed object handles in ObjectAttributesManager. This should only be called internally.
auto checkExistsWithMessage(const std::string& objectHandle, const std::string& src) const -> bool
Used Internally. Checks if managed object handle exists in map; if not prints an error message, returns false; Otherwise returns true;.
auto getUnusedObjectID() -> int
Used Internally. Get an unused/available ID to be assigned to an object as it is being added to the library.
auto getRandomObjectHandlePerType(const std::unordered_map<int, std::string>& mapOfHandles, const std::string& type) const -> std::string
Return a random handle selected from the passed map.
auto getUniqueHandleFromCandidatePerType(const std::unordered_map<int, std::string>& mapOfHandles, const std::string& name) const -> std::string
return a unique handle given the passed object handle candidate substring among all passed types. If there are no existing ManagedObjects with the passed handle within the passed map, then the passed value will be returned; Otherwise, an incremented handle will be returned, based on the names present.
auto getObjectHandlesBySubStringPerType(const std::unordered_map<int, std::string>& mapOfHandles, const std::string& subStr, bool contains, bool sorted) const -> std::vector<std::string>
Get a list of all managed objects of passed type whose origin handles contain substr, ignoring subStr's case.
auto getObjectHandlesBySubStringPerType(const std::unordered_map<std::string, std::set<std::string>>& mapOfHandles, const std::string& subStr, bool contains, bool sorted) const -> std::vector<std::string>
Get a list of all managed objects of passed type whose origin handles contain substr, ignoring subStr's case.
void deleteObjectInternal(int objectID, const std::string& objectHandle)
Called internally only. Remove all references from libraries for object with passed ID and handle.
void resetFinalize() pure virtual
Any implementation-specific resetting that needs to happen on reset.

Protected variables

std::unordered_map<std::string, std::shared_ptr<void>> objectLibrary_
Maps string keys to managed object managed objects.
const std::string objectType_
A descriptive name of the managed object being managed by this manager.
std::unordered_map<int, std::string> objectLibKeyByID_
Maps all object attribute IDs to the appropriate handles used by lib.
std::deque<int> availableObjectIDs_
Deque holding all IDs of deleted objects. These ID's should be recycled before using map-size-based IDs.
std::set<std::string> undeletableObjectNames_
set holding string managed object handles of all system-locked managed objects, to make sure they are never deleted. Should not be overridden by user.
std::set<std::string> userLockedObjectNames_
set holding string managed object handles of all user-locked managed objects, to make sure they are not deleted unless the user unlocks them.

Function documentation

bool esp::core::managedContainers::ManagedContainerBase::setLock(const std::string& objectHandle, bool lock)

Sets/Clears lock state for a managed object, preventing or allowing deletion of managed object.

Parameters
objectHandle handle of managed object to set state of
lock boolean to set or clear lock
Returns whether successful or not.

std::vector<std::string> esp::core::managedContainers::ManagedContainerBase::setLockByHandles(const std::vector<std::string>& objectHandles, bool lock)

Sets/Clears lock state for a managed object, preventing or allowing deletion of managed object.

Parameters
objectHandles Vector of handles of managed objects to set state of
lock boolean to set or clear lock for all managed objects
Returns the list of handles actually set to desired lock state.

int esp::core::managedContainers::ManagedContainerBase::getObjectIDByHandle(const std::string& objectHandle)

Get the ID of the managed object in ManagedContainerBase::objectLibrary_ for the given managed object Handle, if exists.

Parameters
objectHandle The string key referencing the managed object in ManagedContainerBase::objectLibrary_. Usually the origin handle.
Returns The object ID for the managed object with the passed handle, or ID_UNDEFINED if none exists.

std::vector<std::string> esp::core::managedContainers::ManagedContainerBase::setLockBySubstring(bool lock, const std::string& subStr = "", bool contains = true)

set lock state on all managed objects that contain passed substring.

Parameters
lock boolean to set or clear lock on managed objects
subStr substring to search for within existing primitive object managed objects
contains whether to search for keys containing, or excluding, substr
Returns A vector containing the managed object handles of managed objects whose lock state has been set to passed state.

std::string esp::core::managedContainers::ManagedContainerBase::getRandomObjectHandle() const

Get the handle for a random managed object registered to this manager.

Returns a randomly selected handle corresponding to a known object managed object, or empty string if none found

std::string esp::core::managedContainers::ManagedContainerBase::getUniqueHandleFromCandidate(const std::string& name) const

return a unique handle given the passed object handle candidate substring. If there are no existing ManagedObjects with the passed handle, then the passed value will be returned; Otherwise, an incremented handle will be returned, based on the names present.

Parameters
name Candidate name for object. If DNE then this string is returned with a count component of 0000; if does exist, then an incrementing scheme will be followed.
Returns A valid, unique name to use for a potential managed object.

std::vector<std::string> esp::core::managedContainers::ManagedContainerBase::getObjectHandlesBySubstring(const std::string& subStr = "", bool contains = true, bool sorted = true) const

Get a list of all managed objects handles that contain, or explicitly do not contain subStr, ignoring subStr's case.

Parameters
subStr substring key to search for within existing managed objects.
contains whether to search for keys containing, or excluding, passed subStr
sorted
Returns vector of 0 or more managed object handles containing the passed substring

bool esp::core::managedContainers::ManagedContainerBase::getIsUndeletable(const std::string& key) const

Returns whether the object with the passed key is undeletable.

Parameters
key Value to look for to check whether undeletable or not.
Returns True if handle exists and is undeletable.

bool esp::core::managedContainers::ManagedContainerBase::getIsUserLocked(const std::string& key) const

Returns whether the object with the passed key is user locked.

Parameters
key Value to look for to check whether locked or not.
Returns True if handle exists and is user-locked.

std::string esp::core::managedContainers::ManagedContainerBase::getObjectHandleByID(const int objectID) const

Get the key in objectLibrary_ for the object managed object with the given unique ID.

Parameters
objectID The unique ID of the desired managed object.
Returns The key referencing the managed object in objectLibrary_, or nullptr if does not exist.

int esp::core::managedContainers::ManagedContainerBase::getNumObjects() const

Gets the number of object managed objects stored in the objectLibrary_.

Returns The size of the objectLibrary_.

bool esp::core::managedContainers::ManagedContainerBase::getObjectLibHasHandle(const std::string& handle) const

Checks whether managed object library has passed string handle as key.

Parameters
handle the key to look for

bool esp::core::managedContainers::ManagedContainerBase::getObjectLibHasID(int ID) const

Checks whether managed object library has an object with passed integer as ID.

Parameters
ID the ID to look for

std::vector<std::string> esp::core::managedContainers::ManagedContainerBase::getObjectInfoStrings(const std::string& subStr = "", bool contains = true) const

Get a vector of strings holding the values of each of the objects this manager manages whose keys match subStr, ignoring subStr's case. Pass an empty string for all objects.

Parameters
subStr substring key to search for within existing managed objects.
contains whether to search for keys containing, or excluding, substr
Returns A vector containing the string info of all the objects in this manager.

int esp::core::managedContainers::ManagedContainerBase::getObjectIDByHandleOrNew(const std::string& objectHandle, bool getNext) protected

Used Internally. Get the ID of the managed object in objectLibrary_ for the given managed object Handle, if exists. If the managed object is not in the library and getNext is true then returns next available id, otherwise throws assertion and returns ID_UNDEFINED.

Parameters
objectHandle The string key referencing the managed object in ManagedContainerBase::objectLibrary_. Usually the origin handle.
getNext Whether to get the next available ID if not found, or to throw an assertion. Defaults to false
Returns The managed object's ID if found. The next available ID if not found and getNext is true. Otherwise ID_UNDEFINED.

template<class U>
auto esp::core::managedContainers::ManagedContainerBase::getObjectInternal(const std::string& handle) const protected

Retrieve shared pointer to object held in library, NOT a copy.

Parameters
handle the name of the object held in the smart pointer

void esp::core::managedContainers::ManagedContainerBase::setObjectInternal(const std::shared_ptr<void>& ptr, const std::string& handle) protected

Only used from class template AddObject method. put the passed smart poitner in the library.

Parameters
ptr the smart pointer to the object being managed
handle the name (key) to use for the object in the library

void esp::core::managedContainers::ManagedContainerBase::deleteObjectInternalFinalize(int objectID, const std::string& objectHandle) pure virtual protected

This method will perform any necessary updating that is ManagedContainer specialization-specific upon managed object removal, such as removing a specific managed object handle from the list of file-based managed object handles in ObjectAttributesManager. This should only be called internally.

Parameters
objectID the ID of the managed object to remove
objectHandle the string key of the managed object to remove.

int esp::core::managedContainers::ManagedContainerBase::getUnusedObjectID() protected

Used Internally. Get an unused/available ID to be assigned to an object as it is being added to the library.

Returns The managed object's ID if found. The next available ID if not found and getNext is true. Otherwise ID_UNDEFINED.

std::string esp::core::managedContainers::ManagedContainerBase::getRandomObjectHandlePerType(const std::unordered_map<int, std::string>& mapOfHandles, const std::string& type) const protected

Return a random handle selected from the passed map.

Parameters
mapOfHandles map containing the desired managed object handles
type the type of managed object being retrieved, for debug message
Returns a random managed object handle of the chosen type, or the empty string if none loaded

std::string esp::core::managedContainers::ManagedContainerBase::getUniqueHandleFromCandidatePerType(const std::unordered_map<int, std::string>& mapOfHandles, const std::string& name) const protected

return a unique handle given the passed object handle candidate substring among all passed types. If there are no existing ManagedObjects with the passed handle within the passed map, then the passed value will be returned; Otherwise, an incremented handle will be returned, based on the names present.

Parameters
mapOfHandles map containing the desired managed object handles
name Candidate name for object. If DNE then this string is returned; if does exist, then an incrementing scheme will be followed.
Returns A valid, unique name to use for a potential managed object.

std::vector<std::string> esp::core::managedContainers::ManagedContainerBase::getObjectHandlesBySubStringPerType(const std::unordered_map<int, std::string>& mapOfHandles, const std::string& subStr, bool contains, bool sorted) const protected

Get a list of all managed objects of passed type whose origin handles contain substr, ignoring subStr's case.

Parameters
mapOfHandles map containing the desired managed object handles
subStr substring to search for within existing managed objects
contains Whether to search for handles containing, or not containing, substr
sorted whether the return vector values are sorted
Returns vector of 0 or more managed object handles containing/not containing the passed substring

This version works on std::unordered_map<int,std::string> maps' values.

std::vector<std::string> esp::core::managedContainers::ManagedContainerBase::getObjectHandlesBySubStringPerType(const std::unordered_map<std::string, std::set<std::string>>& mapOfHandles, const std::string& subStr, bool contains, bool sorted) const protected

Get a list of all managed objects of passed type whose origin handles contain substr, ignoring subStr's case.

Parameters
mapOfHandles map containing the desired keys to search.
subStr substring to search for within existing managed objects
contains Whether to search for handles containing, or not containing, substr
sorted whether the return vector values are sorted
Returns vector of 0 or more managed object handles containing/not containing the passed substring

This version works on std::unordered_map<std::string, std::set<std::string>> maps's keys.

void esp::core::managedContainers::ManagedContainerBase::deleteObjectInternal(int objectID, const std::string& objectHandle) protected

Called internally only. Remove all references from libraries for object with passed ID and handle.

Parameters
objectID the ID of the object to remove.
objectHandle the handle of the object to remove.