asskoala/CKG
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
Jose Caban
2025-06-07 11:34:38 -04:00
commit 0eb2d7c07d
4708 changed files with 1500614 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

243
extern/stdcxx/4.2.1/include/rw/_autoptr.h vendored Normal file
View File

@@ -0,0 +1,243 @@
// -*- C++ -*-
/***************************************************************************
*
* _autoptr.h - definition of the class template auto_ptr
*
* This is an internal header file used to implement the C++ Standard
* Library. It should never be #included directly by a program.
*
* $Id: _autoptr.h 448928 2006-09-22 13:43:18Z faridz $
*
***************************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
* implied. See the License for the specific language governing
* permissions and limitations under the License.
*
* Copyright 1994-2006 Rogue Wave Software.
*
**************************************************************************/
#ifndef _RWSTD_RW_AUTOPTR_H_INCLUDED
#define _RWSTD_RW_AUTOPTR_H_INCLUDED
#ifndef _RWSTD_RW_DEFS_H_INCLUDED
# include <rw/_defs.h>
#endif // _RWSTD_RW_DEFS_H_INCLUDED
_RWSTD_NAMESPACE (__rw) {
template <class _TypeT>
struct __rw_nonvoid_ref
{
typedef _TypeT& _C_ref;
};
_RWSTD_SPECIALIZED_CLASS
struct __rw_nonvoid_ref<void>
{
// makes the declaration of auto_ptr<void>::operator*() well-formed
// (the function definition itself may still be ill-formed and must
// not be instantiated)
typedef void _C_ref;
};
#ifndef _RWSTD_NO_CV_VOID_SPECIALIZATIONS
_RWSTD_SPECIALIZED_CLASS
struct __rw_nonvoid_ref<const void>
{
typedef void _C_ref;
};
_RWSTD_SPECIALIZED_CLASS
struct __rw_nonvoid_ref<volatile void>
{
typedef void _C_ref;
};
_RWSTD_SPECIALIZED_CLASS
struct __rw_nonvoid_ref<const volatile void>
{
typedef void _C_ref;
};
#endif // _RWSTD_NO_CV_VOID_SPECIALIZATIONS
} // namespace __rw
_RWSTD_NAMESPACE (std) {
// 20.4.5 - Template class auto_ptr
template <class _TypeT>
class auto_ptr;
// 20.4.5, p2 (defined outside of auto_ptr<> according to the proposed
// resolution of lwg issue 127)
template <class _TypeT>
class auto_ptr_ref
{
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
template <class _TypeU>
friend class auto_ptr;
// implicit conversion from auto_ptr<U> available only
// if U* is implicitly convertible to T* (via inheritance)
template <class _TypeU>
auto_ptr_ref (auto_ptr<_TypeU>& __rhs, const _TypeU* = 0) _THROWS (())
: _C_ptr (_RWSTD_REINTERPRET_CAST (auto_ptr<_TypeT>&, __rhs)) { }
#else // if defined (_RWSTD_NO_MEMBER_TEMPLATES)
public:
// useless, auto_ptr_ref necessary only for auto_ptr conversions
auto_ptr_ref (auto_ptr<_TypeT>& __rhs, const _TypeT* = 0) _THROWS (())
: _C_ptr (__rhs) { }
#endif // _RWSTD_NO_MEMBER_TEMPLATES
// reference to the owning auto_ptr object
auto_ptr<_TypeT>& _C_ptr;
};
template<class _TypeT>
class auto_ptr
{
public:
typedef _TypeT element_type;
// 20.4.5.1, p1
_EXPLICIT auto_ptr (element_type* __p = 0) _THROWS (())
: _C_ptr (__p) { }
// 20.4.5.1, p2
auto_ptr (auto_ptr& __rhs) _THROWS (())
: _C_ptr (__rhs.release ()) { }
// 20.4.5.1, p7
auto_ptr& operator= (auto_ptr& __rhs) _THROWS (()) {
reset (__rhs.release ());
return *this;
}
// 20.4.5.1, p13
~auto_ptr () _THROWS (()) {
delete _C_ptr;
}
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
// 20.4.5.1, p4
template <class _TypeU>
auto_ptr (auto_ptr<_TypeU>& __rhs) _THROWS (())
: _C_ptr (__rhs.release ()) { }
// 20.4.5.1, p10
template <class _TypeU>
auto_ptr& operator= (auto_ptr<_TypeU>& __rhs) _THROWS (()) {
reset (__rhs.release ());
return *this;
}
// 20.4.5.3, p3
template <class _TypeU>
operator auto_ptr_ref<_TypeU>() _THROWS (()) {
// convertible only if T* is implicitly convertible to U*
return auto_ptr_ref<_TypeU>(*this, _C_ptr);
}
// 20.4.5.3, p4
template <class _TypeU>
operator auto_ptr<_TypeU>() _THROWS (()) {
return auto_ptr<_TypeU>(release ());
}
#else // if defined (_RWSTD_NO_MEMBER_TEMPLATES)
// 20.4.5.3, p3 (limited to T == U)
operator auto_ptr_ref<_TypeT>() _THROWS (()) {
return auto_ptr_ref<_TypeT>(*this, _C_ptr);
}
#endif // _RWSTD_NO_MEMBER_TEMPLATES
// 20.4.5.2, p1
_TYPENAME _RW::__rw_nonvoid_ref<element_type>::_C_ref
operator* () const _THROWS (()) {
_RWSTD_ASSERT (0 != get ());
return *get ();
}
#ifndef _RWSTD_NO_NONCLASS_ARROW_RETURN
// 20.4.5.2, p3
element_type* operator->() const _THROWS (()) {
// avoid using the _RWSTD_OPERATOR_ARROW() helper macro
// (defined in terms of operator*()) in order to permit
// auto_ptr<void>::operator->() to be instantiated
return _C_ptr;
}
#endif // _RWSTD_NO_NONCLASS_ARROW_RETURN
// 20.4.5.2, p4
element_type* get () const _THROWS (()) {
return _C_ptr;
}
// 20.4.5.2, p5
element_type* release () _THROWS (()) {
element_type* __tmp = _C_ptr;
_C_ptr = 0;
return __tmp;
}
// 20.4.5.2, p7
void reset (element_type* __p = 0) _THROWS (()) {
if (_C_ptr != __p) {
delete _C_ptr;
_C_ptr = __p;
}
}
// 20.4.5.3, p1
auto_ptr (auto_ptr_ref<element_type> __r) _THROWS (())
: _C_ptr (__r._C_ptr.release ()) { }
// 20.4.5.3, p? - follows lwg issue 127
auto_ptr& operator= (auto_ptr_ref<element_type> __rhs) _THROWS (()) {
reset (__rhs._C_ptr.release ());
return *this;
}
private:
element_type* _C_ptr;
};
} // namespace std
#endif // _RWSTD_RW_AUTOPTR_H_INCLUDED