文件位置：young/y_allocator.hpp
/*
The young Library
Copyright (c) 2005 by 杨桓
Permission to use, copy, modify, distribute and sell this software for any
purpose is hereby granted without fee, provided that the above copyright
notice appear in all copies and that both that copyright notice and this
permission notice appear in supporting documentation.
The author make no representations about the suitability of this software
for any purpose. It is provided "as is" without express or implied warranty.
*/
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
#ifndef __MACRO_CPLUSPLUS_YOUNG_LIBRARY_ALLOCATOR_HEADER_FILE__
#define __MACRO_CPLUSPLUS_YOUNG_LIBRARY_ALLOCATOR_HEADER_FILE__
//-----------------------------------------------------------------------------
#include <new>
#include "y_define.hpp"
//-----------------------------------------------------------------------------
__MACRO_CPLUSPLUS_YOUNG_LIBRARY_BEGIN_NAMESPACE__
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
template< typename T >
class allocator
{
public:
typedef T value_type;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef value_type* iterator;
typedef const value_type* const_iterator;
typedef def_size_t size_type;
typedef def_ptrdiff_t difference_type;
typedef allocator<T> self;
template< typename U >
struct rebind
{
typedef allocator<U> other;
};
template< typename U >
allocator( const allocator<U>& ) throw() {}
template< typename U >
self& operator=( const allocator<U>& ) throw() { return *this; }
allocator() throw() {}
allocator( const self& ) throw() {}
self& operator=( const self& ) throw() { return *this; }
~allocator() throw() {}
pointer address( reference X ) throw() { return ( &X ); }
const_pointer address( const_reference X ) throw() { return ( &X ); }
size_type max_size()
{
return size_type( size_t_max / sizeof(T) );
}
pointer allocate( size_type n, const void* = NULL_POINTER )
{
return (pointer)( operator new( sizeof(T) * n ) );
}
void deallocate( pointer ptr, size_type n = 0 )
{
operator delete( ptr );
}
void construct( pointer ptr, const T& value )
{
new(ptr) T(value);
}
void destroy( pointer ptr )
{
ptr->~T();
}
}; //end allocator
template<>
class allocator<void>
{
public:
typedef void* pointer;
typedef const void* const_pointer;
typedef void value_type;
typedef def_ptrdiff_t difference_type;
typedef allocator<void> self;
template< typename U >
struct rebind
{
typedef allocator<U> other;
};
};
template< typename T >
inline bool operator==( const allocator<T>&, const allocator<T>& ) throw()
{
return true;
}
template< typename T >
inline bool operator!=( const allocator<T>&, const allocator<T>& ) throw()
{
return false;
}
template< typename T, typename U >
inline bool operator==( const allocator<T>&, const allocator<U>& ) throw()
{
return false;
}
template< typename T, typename U >
inline bool operator!=( const allocator<T>&, const allocator<U>& ) throw()
{
return true;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
__MACRO_CPLUSPLUS_YOUNG_LIBRARY_END_NAMESPACE__
#endif
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
文件位置：young/y_construct.hpp
/*
The young Library
Copyright (c) 2005 by 杨桓
Permission to use, copy, modify, distribute and sell this software for any
purpose is hereby granted without fee, provided that the above copyright
notice appear in all copies and that both that copyright notice and this
permission notice appear in supporting documentation.
The author make no representations about the suitability of this software
for any purpose. It is provided "as is" without express or implied warranty.
*/
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
#ifndef __MACRO_CPLUSPLUS_YOUNG_LIBRARY_CONSTRUCT_HEADER_FILE__
#define __MACRO_CPLUSPLUS_YOUNG_LIBRARY_CONSTRUCT_HEADER_FILE__
//-----------------------------------------------------------------------------
#include "y_iterator.hpp"
//-----------------------------------------------------------------------------
__MACRO_CPLUSPLUS_YOUNG_LIBRARY_BEGIN_NAMESPACE__
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
template< typename T1, typename T2 >
inline void construct( T1* ptr, const T2& value )
{
typedef typename type_traits<T1>::is_POD_type POD;
construct_aux( ptr, value, POD() );
}
template< typename T1, typename T2 >
inline void construct_aux( T1* ptr, const T2& value, false_type )
{
new(ptr) T1(value);
}
template< typename T1, typename T2 >
inline void construct_aux( T1* ptr, const T2& value, true_type )
{
*ptr = value;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
template< typename T >
inline void destroy( T* ptr )
{
typedef typename type_traits<T>::has_trivial_destructor destructor;
destroy_aux( ptr, destructor() );
}
template< typename T >
inline void destroy_aux( T* ptr, true_type ) {}
template< typename T >
inline void destroy_aux( T* ptr, false_type ) { ptr->~T(); }
template< typename ForwardIterator >
inline void destroy( ForwardIterator first, ForwardIterator last )
{
typedef typename iterator_traits<ForwardIterator>::iterator_category
cate;
typedef typename iterator_traits<ForwardIterator>::value_type value_t;
typedef typename type_traits<value_t>::has_trivial_destructor destructor;
destroy_aux( first, last, destructor(), cate() );
}
template< typename ForwardIterator >
inline void destroy_aux( ForwardIterator first, ForwardIterator last,
true_type, forward_iterator_tag ) {}
template< typename ForwardIterator >
void destroy_aux( ForwardIterator first, ForwardIterator last,
false_type x, forward_iterator_tag )
{
ForwardIterator temp;
while( first != last )
{
temp = first;
++first;
destroy_aux( &(*temp), x );
}
}
template< typename ForwardIterator >
void destroy_aux( ForwardIterator first, ForwardIterator last,
false_type x, bidirectional_iterator_tag )
{
ForwardIterator temp = --last;
while( last != first )
{
--last;
destroy_aux( &(*temp), x );
temp = last;
}
destroy_aux( &(*first), x );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
__MACRO_CPLUSPLUS_YOUNG_LIBRARY_END_NAMESPACE__
#endif
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
文件位置：young/y_exception.hpp
/*
The young Library
Copyright (c) 2005 by 杨桓
Permission to use, copy, modify, distribute and sell this software for any
purpose is hereby granted without fee, provided that the above copyright
notice appear in all copies and that both that copyright notice and this
permission notice appear in supporting documentation.
The author make no representations about the suitability of this software
for any purpose. It is provided "as is" without express or implied warranty.
*/
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
#ifndef __MACRO_CPLUSPLUS_YOUNG_LIBRARY_EXCEPTION_HEADER_FILE__
#define __MACRO_CPLUSPLUS_YOUNG_LIBRARY_EXCEPTION_HEADER_FILE__
//-----------------------------------------------------------------------------
#include <stdexcept>
#include "y_define.hpp"
//-----------------------------------------------------------------------------
__MACRO_CPLUSPLUS_YOUNG_LIBRARY_BEGIN_NAMESPACE__
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
inline void throw_logic_error( const char* error_info )
{
throw std::logic_error( error_info );
}
inline void throw_domain_error( const char* error_info )
{
throw std::domain_error( error_info );
}
inline void throw_invalid_argument( const char* error_info )
{
throw std::invalid_argument( error_info );
}
inline void throw_length_error( const char* error_info )
{
throw std::length_error( error_info );
}
inline void throw_out_of_range( const char* error_info )
{
throw std::out_of_range( error_info );
}
inline void throw_runtime_error( const char* error_info )
{
throw std::runtime_error( error_info );
}
inline void throw_overflow_error( const char* error_info )
{
throw std::overflow_error( error_info );
}
inline void throw_range_error( const char* error_info )
{
throw std::range_error( error_info );
}
inline void throw_underflow_error( const char* error_info )
{
throw std::underflow_error( error_info );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
__MACRO_CPLUSPLUS_YOUNG_LIBRARY_END_NAMESPACE__
#endif
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
