mangos-mirror/server
0
0
Fork 0
mirror of https://github.com/mangosfour/server.git synced 2025-12-12 01:37:00 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
server/dep/acelite/ace/Caching_Utility_T.cpp
Antz 9285191873
Add files back
2023-01-01 00:55:45 +00:00

500 lines
19 KiB
C++
Raw Blame History

// $Id: Caching_Utility_T.cpp 92264 2010-10-19 18:12:46Z olli $
#ifndef ACE_CACHING_UTILITY_T_CPP
#define ACE_CACHING_UTILITY_T_CPP
#include "ace/Caching_Utility_T.h"
#if !defined (ACE_LACKS_PRAGMA_ONCE)
#pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */
#include "ace/ACE.h"
#include "ace/Min_Max.h"
#include "ace/OS_Memory.h"
#include "ace/Recyclable.h"
//////////////////////////////////////////////////////////////////////////////
ACE_BEGIN_VERSIONED_NAMESPACE_DECL
template <class KEY, class VALUE, class CONTAINER, class ITERATOR, class ATTRIBUTES>
ACE_Pair_Caching_Utility<KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES>::ACE_Pair_Caching_Utility (ACE_Cleanup_Strategy<KEY, VALUE, CONTAINER> *cleanup_strategy,
bool delete_cleanup_strategy)
: cleanup_strategy_ (cleanup_strategy),
delete_cleanup_strategy_ (delete_cleanup_strategy)
{
if (cleanup_strategy == 0)
{
ACE_NEW (this->cleanup_strategy_,
CLEANUP_STRATEGY);
this->delete_cleanup_strategy_ = true;
}
}
template <class KEY, class VALUE, class CONTAINER, class ITERATOR, class ATTRIBUTES>
ACE_Pair_Caching_Utility<KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES>::~ACE_Pair_Caching_Utility (void)
{
if (this->delete_cleanup_strategy_)
delete this->cleanup_strategy_;
}
template <class KEY, class VALUE, class CONTAINER, class ITERATOR, class ATTRIBUTES> int
ACE_Pair_Caching_Utility<KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES>::clear_cache (CONTAINER &container,
double purge_percent)
{
// Check that the purge_percent is non-zero.
if (ACE::is_equal (purge_percent, 0.0))
return 0;
// Get the number of entries in the container.
size_t current_map_size = container.current_size ();
// Also whether the number of entries in the cache!
// Oops! then there is no way out but exiting. So return an error.
if (current_map_size == 0)
return 0;
// Calculate the no of entries to remove from the cache depending
// upon the <purge_percent>.
size_t const entries_to_remove
= ACE_MAX (static_cast<size_t> (1),
static_cast<size_t> (static_cast<double> (purge_percent)
/ 100 * current_map_size));
KEY *key_to_remove = 0;
VALUE *value_to_remove = 0;
for (size_t i = 0; i < entries_to_remove ; ++i)
{
this->minimum (container,
key_to_remove,
value_to_remove);
// Simply verifying that the key is non-zero.
// This is important for strategies where the minimum
// entry cant be found due to constraints on the type of entry
// to remove.
if (key_to_remove == 0)
return 0;
if (this->cleanup_strategy_->cleanup (container,
key_to_remove,
value_to_remove) == -1)
return -1;
}
return 0;
}
template <class KEY, class VALUE, class CONTAINER, class ITERATOR, class ATTRIBUTES> void
ACE_Pair_Caching_Utility<KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES>::minimum (CONTAINER &container,
KEY *&key_to_remove,
VALUE *&value_to_remove)
{
// Starting values.
ITERATOR iter = container.begin ();
ITERATOR end = container.end ();
ATTRIBUTES min = (*iter).int_id_.second;
key_to_remove = &(*iter).ext_id_;
value_to_remove = &(*iter).int_id_;
// The iterator moves thru the container searching for the entry
// with the lowest ATTRIBUTES.
for (++iter;
iter != end;
++iter)
{
if (min > (*iter).int_id_.second)
{
// Ah! an item with lower ATTTRIBUTES...
min = (*iter).int_id_.second;
key_to_remove = &(*iter).ext_id_;
value_to_remove = &(*iter).int_id_;
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
template <class KEY, class VALUE, class CONTAINER, class ITERATOR, class ATTRIBUTES>
ACE_Recyclable_Handler_Caching_Utility<KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES>::ACE_Recyclable_Handler_Caching_Utility (ACE_Cleanup_Strategy<KEY, VALUE, CONTAINER> *cleanup_strategy,
bool delete_cleanup_strategy)
: cleanup_strategy_ (cleanup_strategy),
delete_cleanup_strategy_ (delete_cleanup_strategy)
{
if (cleanup_strategy == 0)
{
ACE_NEW (this->cleanup_strategy_,
CLEANUP_STRATEGY);
this->delete_cleanup_strategy_ = true;
}
}
template <class KEY, class VALUE, class CONTAINER, class ITERATOR, class ATTRIBUTES>
ACE_Recyclable_Handler_Caching_Utility<KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES>::~ACE_Recyclable_Handler_Caching_Utility (void)
{
if (this->delete_cleanup_strategy_)
delete this->cleanup_strategy_;
}
template <class KEY, class VALUE, class CONTAINER, class ITERATOR, class ATTRIBUTES> int
ACE_Recyclable_Handler_Caching_Utility<KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES>::clear_cache (CONTAINER &container,
double purge_percent)
{
// Check that the purge_percent is non-zero.
if (ACE::is_equal (purge_percent, 0.0))
return 0;
// Get the number of entries in the container.
size_t current_map_size = container.current_size ();
// Also whether the number of entries in the cache is just one!
// Oops! then there is no way out but exiting. So return an error.
// if (current_map_size <= 1)
if (current_map_size == 0)
return 0;
// Calculate the no of entries to remove from the cache depending
// upon the <purge_percent>.
size_t const entries_to_remove
= ACE_MAX (static_cast<size_t> (1),
static_cast<size_t> (static_cast<double> (purge_percent)
/ 100 * current_map_size));
KEY *key_to_remove = 0;
VALUE *value_to_remove = 0;
for (size_t i = 0; i < entries_to_remove ; ++i)
{
this->minimum (container,
key_to_remove,
value_to_remove);
// Simply verifying that the key is non-zero.
// This is important for strategies where the minimum
// entry cant be found due to constraints on the type of entry
// to remove.
if (key_to_remove == 0)
return 0;
if (this->cleanup_strategy_->cleanup (container,
key_to_remove,
value_to_remove) == -1)
return -1;
}
return 0;
}
template <class KEY, class VALUE, class CONTAINER, class ITERATOR, class ATTRIBUTES> void
ACE_Recyclable_Handler_Caching_Utility<KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES>::minimum (CONTAINER &container,
KEY *&key_to_remove,
VALUE *&value_to_remove)
{
// Starting values.
ITERATOR end = container.end ();
ITERATOR iter = container.begin ();
ATTRIBUTES min = (*iter).int_id_.second;
key_to_remove = 0;
value_to_remove = 0;
// Found the minimum entry to be purged?
int found = 0;
// The iterator moves thru the container searching for the entry
// with the lowest ATTRIBUTES.
for (;
iter != end;
++iter)
{
// If the <min> entry isnt IDLE_AND_PURGABLE continue until you reach
// the first entry which can be purged. This is the minimum with
// which you will compare the rest of the purgable entries.
if ((*iter).ext_id_.recycle_state () == ACE_RECYCLABLE_IDLE_AND_PURGABLE ||
(*iter).ext_id_.recycle_state () == ACE_RECYCLABLE_PURGABLE_BUT_NOT_IDLE)
{
if (found == 0)
{
min = (*iter).int_id_.second;
key_to_remove = &(*iter).ext_id_;
value_to_remove = &(*iter).int_id_;
found = 1;
}
else
{
// Ah! an entry with lower ATTTRIBUTES...
if (min > (*iter).int_id_.second)
{
min = (*iter).int_id_.second;
key_to_remove = &(*iter).ext_id_;
value_to_remove = &(*iter).int_id_;
}
}
}
}
}
////////////////////////////////////////////////////////////////////////////////
template <class KEY, class VALUE, class CONTAINER, class ITERATOR, class ATTRIBUTES>
ACE_Refcounted_Recyclable_Handler_Caching_Utility<KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES>::ACE_Refcounted_Recyclable_Handler_Caching_Utility (ACE_Cleanup_Strategy<KEY, VALUE, CONTAINER> *cleanup_strategy,
bool delete_cleanup_strategy)
: cleanup_strategy_ (cleanup_strategy),
delete_cleanup_strategy_ (delete_cleanup_strategy),
marked_as_closed_entries_ (0)
{
if (cleanup_strategy == 0)
{
ACE_NEW (this->cleanup_strategy_,
CLEANUP_STRATEGY);
this->delete_cleanup_strategy_ = true;
}
}
template <class KEY, class VALUE, class CONTAINER, class ITERATOR, class ATTRIBUTES>
ACE_Refcounted_Recyclable_Handler_Caching_Utility<KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES>::~ACE_Refcounted_Recyclable_Handler_Caching_Utility (void)
{
if (this->delete_cleanup_strategy_)
delete this->cleanup_strategy_;
}
template <class KEY, class VALUE, class CONTAINER, class ITERATOR, class ATTRIBUTES> int
ACE_Refcounted_Recyclable_Handler_Caching_Utility<KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES>::clear_cache (CONTAINER &container,
double purge_percent)
{
// Check that the purge_percent is non-zero.
if (ACE::is_equal (purge_percent, 0.0))
return 0;
// Get the number of entries in the container which can be considered for purging.
size_t const available_entries =
container.current_size () - this->marked_as_closed_entries_;
// Also whether the number of entries in the cache zero.
// Oops! then there is no way out but exiting.
if (available_entries <= 0)
return 0;
// Calculate the no of entries to remove from the cache depending
// upon the <purge_percent>.
size_t entries_to_remove
= ACE_MAX (static_cast<size_t> (1),
static_cast<size_t> (static_cast<double> (purge_percent)
/ 100 * available_entries));
if (entries_to_remove >= available_entries || entries_to_remove == 0)
entries_to_remove = available_entries - 1;
KEY *key_to_remove = 0;
VALUE *value_to_remove = 0;
for (size_t i = 0; i < entries_to_remove ; ++i)
{
this->minimum (container,
key_to_remove,
value_to_remove);
// Simply verifying that the key is non-zero.
// This is important for strategies where the minimum
// entry cant be found due to constraints on the type of entry
// to remove.
if (key_to_remove == 0)
return 0;
if (this->cleanup_strategy_->cleanup (container,
key_to_remove,
value_to_remove) == -1)
return -1;
++this->marked_as_closed_entries_;
}
return 0;
}
template <class KEY, class VALUE, class CONTAINER, class ITERATOR, class ATTRIBUTES> void
ACE_Refcounted_Recyclable_Handler_Caching_Utility<KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES>::minimum (CONTAINER &container,
KEY *&key_to_remove,
VALUE *&value_to_remove)
{
// Starting values.
ITERATOR end = container.end ();
ITERATOR iter = container.begin ();
ATTRIBUTES min = (*iter).int_id_.second ();
key_to_remove = 0;
value_to_remove = 0;
// Found the minimum entry to be purged?
int found = 0;
// The iterator moves thru the container searching for the entry
// with the lowest ATTRIBUTES.
for (;
iter != end;
++iter)
{
// If the <min> entry isnt IDLE_AND_PURGABLE continue until you reach
// the first entry which can be purged. This is the minimum with
// which you will compare the rest of the purgable entries.
if ((*iter).ext_id_.recycle_state () == ACE_RECYCLABLE_IDLE_AND_PURGABLE ||
(*iter).ext_id_.recycle_state () == ACE_RECYCLABLE_PURGABLE_BUT_NOT_IDLE)
{
if (found == 0)
{
min = (*iter).int_id_.second ();
key_to_remove = &(*iter).ext_id_;
value_to_remove = &(*iter).int_id_;
found = 1;
}
else
{
// Ah! an entry with lower ATTTRIBUTES...
if (min > (*iter).int_id_.second ())
{
min = (*iter).int_id_.second ();
key_to_remove = &(*iter).ext_id_;
value_to_remove = &(*iter).int_id_;
}
}
}
}
}
////////////////////////////////////////////////////////////////////////////////
template <class KEY, class VALUE, class CONTAINER, class ITERATOR, class ATTRIBUTES>
ACE_Handler_Caching_Utility<KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES>::ACE_Handler_Caching_Utility (ACE_Cleanup_Strategy<KEY, VALUE, CONTAINER> *cleanup_strategy,
bool delete_cleanup_strategy)
: cleanup_strategy_ (cleanup_strategy),
delete_cleanup_strategy_ (delete_cleanup_strategy)
{
if (cleanup_strategy == 0)
{
ACE_NEW (this->cleanup_strategy_,
CLEANUP_STRATEGY);
this->delete_cleanup_strategy_ = true;
}
}
template <class KEY, class VALUE, class CONTAINER, class ITERATOR, class ATTRIBUTES>
ACE_Handler_Caching_Utility<KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES>::~ACE_Handler_Caching_Utility (void)
{
if (this->delete_cleanup_strategy_)
delete this->cleanup_strategy_;
}
template <class KEY, class VALUE, class CONTAINER, class ITERATOR, class ATTRIBUTES> int
ACE_Handler_Caching_Utility<KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES>::clear_cache (CONTAINER &container,
double purge_percent)
{
// Check that the purge_percent is non-zero.
if (ACE::is_equal (purge_percent, 0.0))
return 0;
// Get the number of entries in the container.
size_t current_map_size = container.current_size ();
// Also whether the number of entries in the cache is just one!
// Oops! then there is no way out but exiting. So return an error.
if (current_map_size == 0)
return 0;
// Calculate the no of entries to remove from the cache depending
// upon the <purge_percent>.
size_t entries_to_remove
= ACE_MAX (static_cast<size_t> (1),
static_cast<size_t> (static_cast<double> (purge_percent)
/ 100 * current_map_size));
KEY *key_to_remove = 0;
VALUE *value_to_remove = 0;
for (size_t i = 0; i < entries_to_remove ; ++i)
{
this->minimum (container,
key_to_remove,
value_to_remove);
if (this->cleanup_strategy_->cleanup (container,
key_to_remove,
value_to_remove) == -1)
return -1;
}
return 0;
}
template <class KEY, class VALUE, class CONTAINER, class ITERATOR, class ATTRIBUTES> void
ACE_Handler_Caching_Utility<KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES>::minimum (CONTAINER &container,
KEY *&key_to_remove,
VALUE *&value_to_remove)
{
// Starting values.
ITERATOR iter = container.begin ();
ITERATOR end = container.end ();
ATTRIBUTES min = (*iter).int_id_->caching_attributes ();
key_to_remove = &(*iter).ext_id_;
value_to_remove = &(*iter).int_id_;
// The iterator moves thru the container searching for the entry
// with the lowest ATTRIBUTES.
for (++iter;
iter != end;
++iter)
{
if (min > (*iter).int_id_->caching_attributes () &&
(*iter).int_id_->active () != 1)
{
// Ah! an item with lower ATTTRIBUTES...
min = (*iter).int_id_->caching_attributes ();
key_to_remove = &(*iter).ext_id_;
value_to_remove = &(*iter).int_id_;
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
template <class KEY, class VALUE, class CONTAINER, class ITERATOR, class ATTRIBUTES>
ACE_Null_Caching_Utility<KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES>::ACE_Null_Caching_Utility (ACE_Cleanup_Strategy<KEY, VALUE, CONTAINER> *cleanup_strategy,
bool delete_cleanup_strategy)
: cleanup_strategy_ (cleanup_strategy),
delete_cleanup_strategy_ (delete_cleanup_strategy)
{
if (cleanup_strategy == 0)
{
ACE_NEW (this->cleanup_strategy_,
CLEANUP_STRATEGY);
this->delete_cleanup_strategy_ = true;
}
}
template <class KEY, class VALUE, class CONTAINER, class ITERATOR, class ATTRIBUTES>
ACE_Null_Caching_Utility<KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES>::~ACE_Null_Caching_Utility (void)
{
if (this->delete_cleanup_strategy_)
delete this->cleanup_strategy_;
}
template <class KEY, class VALUE, class CONTAINER, class ITERATOR, class ATTRIBUTES> int
ACE_Null_Caching_Utility<KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES>::clear_cache (CONTAINER &container,
double purge_percent)
{
ACE_UNUSED_ARG (container);
ACE_UNUSED_ARG (purge_percent);
return 0;
}
template <class KEY, class VALUE, class CONTAINER, class ITERATOR, class ATTRIBUTES> void
ACE_Null_Caching_Utility<KEY, VALUE, CONTAINER, ITERATOR, ATTRIBUTES>::minimum (CONTAINER &container,
KEY *&key_to_remove,
VALUE *&value_to_remove)
{
ACE_UNUSED_ARG (container);
ACE_UNUSED_ARG (key_to_remove);
ACE_UNUSED_ARG (value_to_remove);
}
ACE_END_VERSIONED_NAMESPACE_DECL
#endif /* ACE_CACHING_UTILITY_T_CPP */
Reference in a new issue View git blame Copy permalink