historical/toontown-classic.git/panda/include/weakNodePath.I
2024-01-16 11:20:27 -06:00

224 lines
5.5 KiB
Text

/**
* PANDA 3D SOFTWARE
* Copyright (c) Carnegie Mellon University. All rights reserved.
*
* All use of this software is subject to the terms of the revised BSD
* license. You should have received a copy of this license along
* with this source code in a file named "LICENSE."
*
* @file weakNodePath.I
* @author drose
* @date 2004-09-29
*/
/**
*
*/
INLINE WeakNodePath::
WeakNodePath(const NodePath &node_path) :
_head(node_path._head),
_backup_key(0)
{
}
/**
*
*/
INLINE WeakNodePath::
WeakNodePath(const WeakNodePath &copy) :
_head(copy._head),
_backup_key(copy._backup_key)
{
}
/**
*
*/
INLINE WeakNodePath::
~WeakNodePath() {
}
/**
*
*/
INLINE void WeakNodePath::
operator = (const NodePath &node_path) {
_head = node_path._head;
_backup_key = 0;
}
/**
*
*/
INLINE void WeakNodePath::
operator = (const WeakNodePath &copy) {
_head = copy._head;
_backup_key = copy._backup_key;
}
/**
* Sets this NodePath to the empty NodePath. It will no longer point to any
* node.
*/
INLINE void WeakNodePath::
clear() {
_head.clear();
_backup_key = 0;
}
/**
* Returns true if this NodePath points to a valid, non-null node.
*/
INLINE WeakNodePath::
operator bool () const {
return _head.is_valid_pointer();
}
/**
* Returns true if the NodePath contains no nodes, or if it has been deleted.
*/
INLINE bool WeakNodePath::
is_empty() const {
return _head == nullptr || _head.was_deleted();
}
/**
* Returns true if the NodePath we were referencing has been quietly deleted
* outside of the WeakNodePath.
*/
INLINE bool WeakNodePath::
was_deleted() const {
return _head != nullptr && _head.was_deleted();
}
/**
* Returns the NodePath held within this object, or an empty NodePath with the
* error flag set if the object was deleted.
*/
INLINE NodePath WeakNodePath::
get_node_path() const {
NodePath result;
result._head = _head.lock();
if (!_head.is_null() && result._head == nullptr) {
result._error_type = NodePath::ET_fail;
}
return result;
}
/**
* Returns the PandaNode held within this object, or nullptr if the object was
* deleted.
*/
INLINE PT(PandaNode) WeakNodePath::
node() const {
if (auto head = _head.lock()) {
return head->get_node();
} else {
return nullptr;
}
}
/**
* Returns true if the two paths are equivalent; that is, if they contain the
* same list of nodes in the same order.
*/
INLINE bool WeakNodePath::
operator == (const NodePath &other) const {
return _head.get_orig() == other._head && !_head.was_deleted();
}
/**
* Returns true if the two paths are not equivalent.
*/
INLINE bool WeakNodePath::
operator != (const NodePath &other) const {
return !operator == (other);
}
/**
* Returns true if this NodePath sorts before the other one, false otherwise.
* The sorting order of two nonequivalent NodePaths is consistent but
* undefined, and is useful only for storing NodePaths in a sorted container
* like an STL set.
*/
INLINE bool WeakNodePath::
operator < (const NodePath &other) const {
return _head.owner_before(other._head);
}
/**
* Returns a number less than zero if this NodePath sorts before the other
* one, greater than zero if it sorts after, or zero if they are equivalent.
*
* Two NodePaths are considered equivalent if they consist of exactly the same
* list of nodes in the same order. Otherwise, they are different; different
* NodePaths will be ranked in a consistent but undefined ordering; the
* ordering is useful only for placing the NodePaths in a sorted container
* like an STL set.
*/
INLINE int WeakNodePath::
compare_to(const NodePath &other) const {
if (operator != (other)) {
return _head.owner_before(other._head) ? -1 : 1;
}
return 0;
}
/**
* Returns true if the two paths are equivalent; that is, if they contain the
* same list of nodes in the same order.
*/
INLINE bool WeakNodePath::
operator == (const WeakNodePath &other) const {
return !_head.owner_before(other._head) && !other._head.owner_before(_head);
}
/**
* Returns true if the two paths are not equivalent.
*/
INLINE bool WeakNodePath::
operator != (const WeakNodePath &other) const {
return _head.owner_before(other._head) || other._head.owner_before(_head);
}
/**
* Returns true if this WeakNodePath sorts before the other one, false
* otherwise. The sorting order of two nonequivalent WeakNodePaths is
* consistent but undefined, and is useful only for storing WeakNodePaths in a
* sorted container like an STL set.
*/
INLINE bool WeakNodePath::
operator < (const WeakNodePath &other) const {
return _head.owner_before(other._head);
}
/**
* Returns a number less than zero if this WeakNodePath sorts before the other
* one, greater than zero if it sorts after, or zero if they are equivalent.
*
* Two WeakNodePaths are considered equivalent if they consist of exactly the
* same list of nodes in the same order. Otherwise, they are different;
* different WeakNodePaths will be ranked in a consistent but undefined
* ordering; the ordering is useful only for placing the WeakNodePaths in a
* sorted container like an STL set.
*/
INLINE int WeakNodePath::
compare_to(const WeakNodePath &other) const {
return other._head.owner_before(_head) - _head.owner_before(other._head);
}
/**
* Returns the same values as NodePath::get_key().
*/
INLINE int WeakNodePath::
get_key() const {
if (auto head = _head.lock()) {
_backup_key = head->get_key();
}
return _backup_key;
}
INLINE std::ostream &operator << (std::ostream &out, const WeakNodePath &node_path) {
node_path.output(out);
return out;
}