Oak End Panels are constructed using 1" thick Solid Oak for started and adder panels.
Maple End Panels utilize a 1" multi ply veneer core for started and adder panels.
Shelves are available in 3/4" solid Oak or Maple.
All units come standard with back panels.
All shelving units feature solid hardwood dovetail jointed frames.
Shelving has the option of having continuous tops or "captured" canopy tops. Canopy tops feature the beveled edge fascia.
Standard Height: 36",42", 48", 60", 72", and 84".
Tesco Learning Environments is committed to making our furniture last a lifetime. While many companies have switched to lower-priced, lower-quality materials, Tesco has not wavered from our commitment to quality. We use more solid hardwoods than any other educational manufacturer.
Despite the trend toward international outsourcing, Tesco continues our commitment to employing hand-selected hardwood from the northern regions of the United States and from supplies that assure responsible forestry management policies.


text:
#ifndef ACE_MAP_T_CPP
#define ACE_MAP_T_CPP

#include "ace/Map_T.h"

#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */

#if !defined (__ACE_INLINE__)
#include "ace/Map_T.inl"
#endif /* __ACE_INLINE__ */

ACE_BEGIN_VERSIONED_NAMESPACE_DECL

template <class KEY, class VALUE>
ACE_Map<KEY, VALUE>::~ACE_Map (void)
{
}

template <class T>
ACE_Iterator_Impl<T>::~ACE_Iterator_Impl (void)
{
}

template <class T>
ACE_Reverse_Iterator_Impl<T>::~ACE_Reverse_Iterator_Impl (void)
{
}

template <class T, class IMPLEMENTATION, class ENTRY>
ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::~ACE_Map_Impl_Iterator_Adapter (void)
{
}

template <class T, class IMPLEMENTATION, class ENTRY> ACE_Iterator_Impl<T> *
ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::clone (void) const
{
  ACE_Iterator_Impl<T> *temp = 0;
  ACE_NEW_RETURN (temp,
                  (ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>) (*this),
                  0);
  return temp;
}

template <class T, class IMPLEMENTATION, class ENTRY> int
ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::compare (const ACE_Iterator_Impl<T> &rhs) const
{
  const ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY> &rhs_local
    = dynamic_cast<const ACE_Map_Impl_Iterator_Adapter< T, IMPLEMENTATION, ENTRY> &> (rhs);

  return this->implementation_ == rhs_local.implementation_;
}

template <class T, class IMPLEMENTATION, class ENTRY> T
ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::dereference () const
{
  ENTRY &entry = *this->implementation_;
  return T (entry.ext_id_,
            entry.int_id_);
}

template <class T, class IMPLEMENTATION, class ENTRY> void
ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::plus_plus (void)
{
  ++this->implementation_;
}

template <class T, class IMPLEMENTATION, class ENTRY> void
ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::minus_minus (void)
{
  --this->implementation_;
}

template <class T, class IMPLEMENTATION, class ENTRY>
ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::~ACE_Map_Impl_Reverse_Iterator_Adapter (void)
{
}

template <class T, class IMPLEMENTATION, class ENTRY> ACE_Reverse_Iterator_Impl<T> *
ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::clone (void) const
{
  ACE_Reverse_Iterator_Impl<T> *temp = 0;
  ACE_NEW_RETURN (temp,
                  (ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>) (*this),
                  0);
  return temp;
}

template <class T, class IMPLEMENTATION, class ENTRY> int
ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const
{
  const ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY> &rhs_local
    = dynamic_cast<const ACE_Map_Impl_Reverse_Iterator_Adapter< T, IMPLEMENTATION, ENTRY> &> (rhs);

  return this->implementation_ == rhs_local.implementation_;
}

template <class T, class IMPLEMENTATION, class ENTRY> T
ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::dereference () const
{
  ENTRY &entry = *this->implementation_;
  return T (entry.ext_id_,
            entry.int_id_);
}

template <class T, class IMPLEMENTATION, class ENTRY> void
ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::plus_plus (void)
{
  ++this->implementation_;
}

template <class T, class IMPLEMENTATION, class ENTRY> void
ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::minus_minus (void)
{
  --this->implementation_;
}

template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY>
ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::~ACE_Map_Impl (void)
{
}

template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::open (size_t length,
                                                                                ACE_Allocator *alloc)
{
  return this->implementation_.open (length,
                                     alloc);
}

template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::close (void)
{
  return this->implementation_.close ();
}

template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::bind (const KEY &key,
                                                                                const VALUE &value)
{
  return this->implementation_.bind (key,
                                     value);
}

template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::bind_modify_key (const VALUE &value,
                                                                                KEY &key)
{
  return this->implementation_.bind_modify_key (value,
                                                key);
}

template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::create_key (KEY &key)
{
  return this->implementation_.create_key (key);
}

template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::bind_create_key (const VALUE &value,
                                                                                KEY &key)
{
  return this->implementation_.bind_create_key (value,
                                                key);
}

template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::bind_create_key (const VALUE &value)
{
  return this->implementation_.bind_create_key (value);
}

template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::recover_key (const KEY &modified_key,
                                                                                KEY &original_key)
{
  return this->implementation_.recover_key (modified_key,
                                            original_key);
}

template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rebind (const KEY &key,
                                                                                const VALUE &value)
{
  return this->implementation_.rebind (key,
                                       value);
}

template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rebind (const KEY &key,
                                                                                const VALUE &value,
                                                                                VALUE &old_value)
{
  return this->implementation_.rebind (key,
                                       value,
                                       old_value);
}

template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rebind (const KEY &key,
                                                                                const VALUE &value,
                                                                                KEY &old_key,
                                                                                VALUE &old_value)
{
  return this->implementation_.rebind (key,
                                       value,
                                       old_key,
                                       old_value);
}

template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::trybind (const KEY &key,
                                                                                VALUE &value)
{
  return this->implementation_.trybind (key,
                                        value);
}

template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::find (const KEY &key,
                                                                                VALUE &value)
{
  return this->implementation_.find (key,
                                     value);
}

template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::find (const KEY &key)
{
  return this->implementation_.find (key);
}

template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::unbind (const KEY &key)
{
  return this->implementation_.unbind (key);
}

template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int
ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::unbind (const KEY &key,
                                                                                VALUE &value)
{
  return this->implementation_.unbind (key,
                                       value);
}

template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> size_t
ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::current_size (void) const
{
  return this->implementation_.current_size ();
}

template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> size_t
ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::total_size (void) const
{
  return this->implementation_.total_size ();
}

template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> void
ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::dump (void) const
{
#if defined (ACE_HAS_DUMP)
  this->implementation_.dump ();
#endif /* ACE_HAS_DUMP */
}

template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::begin_impl (void)
{
  ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
  ACE_NEW_RETURN (temp,
                  iterator_impl (this->implementation_.begin ()),
                  0);
  return temp;
}

template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::end_impl (void)
{
  ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
  ACE_NEW_RETURN (temp,
                  iterator_impl (this->implementation_.end ()),
                  0);
  return temp;
}

template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rbegin_impl (void)
{
  ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
  ACE_NEW_RETURN (temp,
                  reverse_iterator_impl (this->implementation_.rbegin ()),
                  0);
  return temp;
}

template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rend_impl (void)
{
  ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
  ACE_NEW_RETURN (temp,
                  reverse_iterator_impl (this->implementation_.rend ()),
                  0);
  return temp;
}

template <class T, class VALUE>
ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::~ACE_Active_Map_Manager_Iterator_Adapter (void)
{
}

template <class T, class VALUE> ACE_Iterator_Impl<T> *
ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::clone (void) const
{
  ACE_Iterator_Impl<T> *temp = 0;
  ACE_NEW_RETURN (temp,
                  (ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>) (*this),
                  0);
  return temp;
}

template <class T, class VALUE> int
ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::compare (const ACE_Iterator_Impl<T> &rhs) const
{
  const ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE> &rhs_local
    = dynamic_cast<const ACE_Active_Map_Manager_Iterator_Adapter< T, VALUE> &> (rhs);

  return this->implementation_ == rhs_local.implementation_;
}

template <class T, class VALUE> T
ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::dereference () const
{
  // The following syntax is necessary to work around certain broken compilers.
  // In particular, please do not prefix implementation_ with this->
  return T ((*implementation_).int_id_.first,
            (*implementation_).int_id_.second);
}

template <class T, class VALUE> void
ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::plus_plus (void)
{
  ++this->implementation_;
}

template <class T, class VALUE> void
ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::minus_minus (void)
{
  --this->implementation_;
}

template <class T, class VALUE>
ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::~ACE_Active_Map_Manager_Reverse_Iterator_Adapter (void)
{
}

template <class T, class VALUE> ACE_Reverse_Iterator_Impl<T> *
ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::clone (void) const
{
  ACE_Reverse_Iterator_Impl<T> *temp = 0;
  ACE_NEW_RETURN (temp,
                  (ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>) (*this),
                  0);
  return temp;
}

template <class T, class VALUE> int
ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const
{
  const ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE> &rhs_local
    = dynamic_cast<const ACE_Active_Map_Manager_Reverse_Iterator_Adapter< T, VALUE> &> (rhs);

  return this->implementation_ == rhs_local.implementation_;
}

template <class T, class VALUE> T
ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::dereference () const
{
  // The following syntax is necessary to work around certain broken compilers.
  // In particular, please do not prefix implementation_ with this->
  return T ((*implementation_).int_id_.first,
            (*implementation_).int_id_.second);
}

template <class T, class VALUE> void
ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::plus_plus (void)
{
  ++this->implementation_;
}

template <class T, class VALUE> void
ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::minus_minus (void)
{
  --this->implementation_;
}

template <class KEY, class VALUE, class KEY_ADAPTER>
ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::~ACE_Active_Map_Manager_Adapter (void)
{
}

template <class KEY, class VALUE, class KEY_ADAPTER> int
ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::open (size_t length,
                                                               ACE_Allocator *alloc)
{
  return this->implementation_.open (length,
                                     alloc);
}

template <class KEY, class VALUE, class KEY_ADAPTER> int
ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::close (void)
{
  return this->implementation_.close ();
}

template <class KEY, class VALUE, class KEY_ADAPTER> int
ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::bind (const KEY &,
                                                               const VALUE &)
{
  ACE_NOTSUP_RETURN (-1);
}

template <class KEY, class VALUE, class KEY_ADAPTER> int
ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::bind_modify_key (const VALUE &value,
                                                                          KEY &key)
{
  // Reserve a slot and create an active key.
  expanded_value *internal_value = 0;
  ACE_Active_Map_Manager_Key active_key;
  int result = this->implementation_.bind (active_key,
                                           internal_value);
  if (result == 0)
    {
      // Encode the active key and the existing user key into key part
      // of <expanded_value>.
      result = this->key_adapter_.encode (key,
                                          active_key,
                                          internal_value->first);
      if (result == 0)
        {
          // Copy user value into <expanded_value>.
          internal_value->second = value;
          // Copy new, modified key back to the user key.
          key = internal_value->first;
        }
      else
        {
          // In case of errors, unbind from map.
          this->implementation_.unbind (active_key);
        }
    }

  return result;
}

template <class KEY, class VALUE, class KEY_ADAPTER> int
ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::create_key (KEY &)
{
  ACE_NOTSUP_RETURN (-1);
}

template <class KEY, class VALUE, class KEY_ADAPTER> int
ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::bind_create_key (const VALUE &value,
                                                                          KEY &key)
{
  // Reserve a slot and create an active key.
  expanded_value *internal_value = 0;
  ACE_Active_Map_Manager_Key active_key;
  int result = this->implementation_.bind (active_key,
                                           internal_value);
  if (result == 0)
    {
      // Encode the active key into key part of <expanded_value>.
      result = this->key_adapter_.encode (internal_value->first,
                                          active_key,
                                          internal_value->first);
      if (result == 0)
        {
          // Copy user value into <expanded_value>.
          internal_value->second = value;
          // Copy new, modified key to the user key.
          key = internal_value->first;
        }
      else
        {
          // In case of errors, unbind from map.
          this->implementation_.unbind (active_key);
        }
    }

  return result;
}

template <class KEY, class VALUE, class KEY_ADAPTER> int
ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::bind_create_key (const VALUE &value)
{
  // Reserve a slot and create an active key.
  expanded_value *internal_value = 0;
  ACE_Active_Map_Manager_Key active_key;
  int result = this->implementation_.bind (active_key,
                                           internal_value);
  if (result == 0)
    {
      // Encode the active key into key part of <expanded_value>.
      result = this->key_adapter_.encode (internal_value->first,
                                          active_key,
                                          internal_value->first);
      if (result == 0)
        {
          // Copy user value into <expanded_value>.
          internal_value->second = value;
        }
      else
        {
          // In case of errors, unbind from map.
          this->implementation_.unbind (active_key);
        }
    }

  return result;
}

template <class KEY, class VALUE, class KEY_ADAPTER> int
ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::recover_key (const KEY &modified_key,
                                                                      KEY &original_key)
{
  // Ask the <key_adapter_> to help out with recovering the original
  // user key, since it was the one that encode it in the first place.
  return this->key_adapter_.decode (modified_key,
                                    original_key);
}

template <class KEY, class VALUE, class KEY_ADAPTER> int
ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::find (const KEY &key,
                                                               expanded_value *&internal_value)
{
  // Ask the <key_adapter_> to recover the active key.
  ACE_Active_Map_Manager_Key active_key;
  int result = this->key_adapter_.decode (key,
                                          active_key);
  if (result == 0)
    {
      // Find recovered active key in map.
      result = this->implementation_.find (active_key,
                                           internal_value);
    }

  return result;
}

template <class KEY, class VALUE, class KEY_ADAPTER> int
ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::find (const KEY &key,
                                                               VALUE &value)
{
  expanded_value *internal_value = 0;
  int result = this->find (key,
                           internal_value);

  if (result == 0)
    {
      // Copy value.
      value = internal_value->second;
    }

  return result;
}

template <class KEY, class VALUE, class KEY_ADAPTER> int
ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::find (const KEY &key)
{
  expanded_value *internal_value = 0;
  return this->find (key,
                     internal_value);
}

template <class KEY, class VALUE, class KEY_ADAPTER> int
ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rebind (const KEY &key,
                                                                 const VALUE &value)
{
  expanded_value *internal_value = 0;
  int result = this->find (key,
                           internal_value);

  if (result == 0)
    {
      // Reset value.
      internal_value->second = value;
    }

  return result;
}

template <class KEY, class VALUE, class KEY_ADAPTER> int
ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rebind (const KEY &key,
                                                                 const VALUE &value,
                                                                 VALUE &old_value)
{
  expanded_value *internal_value = 0;
  int result = this->find (key,
                           internal_value);

  if (result == 0)
    {
      // Copy old value.
      old_value = internal_value->second;

      // Reset to new value.
      internal_value->second = value;
    }

  return result;
}

template <class KEY, class VALUE, class KEY_ADAPTER> int
ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rebind (const KEY &key,
                                                                 const VALUE &value,
                                                                 KEY &old_key,
                                                                 VALUE &old_value)
{
  expanded_value *internal_value = 0;
  int result = this->find (key,
                           internal_value);

  if (result == 0)
    {
      // Copy old key and value.
      old_key = internal_value->first;
      old_value = internal_value->second;

      // Reset to new value.
      internal_value->second = value;
    }

  return result;
}

template <class KEY, class VALUE, class KEY_ADAPTER> int
ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::trybind (const KEY &,
                                                                  VALUE &)
{
  ACE_NOTSUP_RETURN (-1);
}

template <class KEY, class VALUE, class KEY_ADAPTER> int
ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::unbind (const KEY &key,
                                                                 expanded_value *&internal_value)
{
  // Ask the <key_adapter_> to recover the active key.
  ACE_Active_Map_Manager_Key active_key;
  int result = this->key_adapter_.decode (key,
                                          active_key);
  if (result == 0)
    {
      // Unbind recovered active key from map.
      result = this->implementation_.unbind (active_key,
                                             internal_value);
    }

  return result;
}

template <class KEY, class VALUE, class KEY_ADAPTER> int
ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::unbind (const KEY &key)
{
  expanded_value *internal_value = 0;
  return this->unbind (key,
                       internal_value);
}

template <class KEY, class VALUE, class KEY_ADAPTER> int
ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::unbind (const KEY &key,
                                                                 VALUE &value)
{
  expanded_value *internal_value = 0;
  int result = this->unbind (key,
                             internal_value);

  if (result == 0)
    {
      // Copy value.
      value = internal_value->second;
    }

  return result;
}

template <class KEY, class VALUE, class KEY_ADAPTER> size_t
ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::current_size (void) const
{
  return this->implementation_.current_size ();
}

template <class KEY, class VALUE, class KEY_ADAPTER> size_t
ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::total_size (void) const
{
  return this->implementation_.total_size ();
}

template <class KEY, class VALUE, class KEY_ADAPTER> void
ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::dump (void) const
{
#if defined (ACE_HAS_DUMP)
  this->implementation_.dump ();
#endif /* ACE_HAS_DUMP */
}

template <class KEY, class VALUE, class KEY_ADAPTER> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::begin_impl (void)
{
  ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
  ACE_NEW_RETURN (temp,
                  iterator_impl (this->implementation_.begin ()),
                  0);
  return temp;
}

template <class KEY, class VALUE, class KEY_ADAPTER> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::end_impl (void)
{
  ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
  ACE_NEW_RETURN (temp,
                  iterator_impl (this->implementation_.end ()),
                  0);
  return temp;
}

template <class KEY, class VALUE, class KEY_ADAPTER> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rbegin_impl (void)
{
  ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
  ACE_NEW_RETURN (temp,
                  reverse_iterator_impl (this->implementation_.rbegin ()),
                  0);
  return temp;
}

template <class KEY, class VALUE, class KEY_ADAPTER> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rend_impl (void)
{
  ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
  ACE_NEW_RETURN (temp,
                  reverse_iterator_impl (this->implementation_.rend ()),
                  0);
  return temp;
}

template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS>
ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::~ACE_Hash_Map_Manager_Ex_Iterator_Adapter (void)
{
}

template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_Iterator_Impl<T> *
ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::clone (void) const
{
  ACE_Iterator_Impl<T> *temp = 0;
  ACE_NEW_RETURN (temp,
                  (ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>) (*this),
                  0);
  return temp;
}

template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> int
ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::compare (const ACE_Iterator_Impl<T> &rhs) const
{
  const ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS> &rhs_local
    = dynamic_cast<const ACE_Hash_Map_Manager_Ex_Iterator_Adapter< T, KEY, VALUE, HASH_KEY, COMPARE_KEYS> &> (rhs);

  return this->implementation_ == rhs_local.implementation_;
}

template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> T
ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::dereference () const
{
  // The following syntax is necessary to work around certain broken compilers.
  // In particular, please do not prefix implementation_ with this->
  return T ((*implementation_).ext_id_,
            (*implementation_).int_id_);
}

template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> void
ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::plus_plus (void)
{
  ++this->implementation_;
}

template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> void
ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::minus_minus (void)
{
  --this->implementation_;
}

template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS>
ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::~ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter (void)
{
}

template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_Reverse_Iterator_Impl<T> *
ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::clone (void) const
{
  ACE_Reverse_Iterator_Impl<T> *temp = 0;
  ACE_NEW_RETURN (temp,
                  (ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>) (*this),
                  0);
  return temp;
}

template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> int
ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const
{
  const ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS> &rhs_local
    = dynamic_cast<const ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter< T, KEY, VALUE, HASH_KEY, COMPARE_KEYS> &> (rhs);

  return this->implementation_ == rhs_local.implementation_;
}

template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> T
ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::dereference () const
{
  // The following syntax is necessary to work around certain broken compilers.
  // In particular, please do not prefix implementation_ with this->
  return T ((*implementation_).ext_id_,
            (*implementation_).int_id_);
}

template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> void
ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::plus_plus (void)
{
  ++this->implementation_;
}

template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> void
ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::minus_minus (void)
{
  --this->implementation_;
}

template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR>
ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::~ACE_Hash_Map_Manager_Ex_Adapter (void)
{
}

template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::open (size_t length,
                                                                                ACE_Allocator *alloc)
{
  return this->implementation_.open (length,
                                     alloc);
}

template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::close (void)
{
  return this->implementation_.close ();
}

template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::bind (const KEY &key,
                                                                                const VALUE &value)
{
  return this->implementation_.bind (key,
                                     value);
}

template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::bind_modify_key (const VALUE &value,
                                                                                KEY &key)
{
  return this->implementation_.bind (key,
                                     value);
}

template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::create_key (KEY &key)
{
  // Invoke the user specified key generation functor.
  return this->key_generator_ (key);
}

template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::bind_create_key (const VALUE &value,
                                                                                KEY &key)
{
  // Invoke the user specified key generation functor.
  int result = this->key_generator_ (key);

  if (result == 0)
    {
      // Try to add.
      result = this->implementation_.bind (key,
                                           value);
    }

  return result;
}

template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::bind_create_key (const VALUE &value)
{
  KEY key;
  return this->bind_create_key (value,
                                key);
}

template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::recover_key (const KEY &modified_key,
                                                                                KEY &original_key)
{
  original_key = modified_key;
  return 0;
}

template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rebind (const KEY &key,
                                                                                const VALUE &value)
{
  return this->implementation_.rebind (key,
                                       value);
}

template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rebind (const KEY &key,
                                                                                const VALUE &value,
                                                                                VALUE &old_value)
{
  return this->implementation_.rebind (key,
                                       value,
                                       old_value);
}

template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rebind (const KEY &key,
                                                                                const VALUE &value,
                                                                                KEY &old_key,
                                                                                VALUE &old_value)
{
  return this->implementation_.rebind (key,
                                       value,
                                       old_key,
                                       old_value);
}

template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::trybind (const KEY &key,
                                                                                VALUE &value)
{
  return this->implementation_.trybind (key,
                                        value);
}

template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::find (const KEY &key,
                                                                                VALUE &value)
{
  return this->implementation_.find (key,
                                     value);
}

template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::find (const KEY &key)
{
  return this->implementation_.find (key);
}

template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::unbind (const KEY &key)
{
  return this->implementation_.unbind (key);
}

template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int
ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::unbind (const KEY &key,
                                                                                VALUE &value)
{
  return this->implementation_.unbind (key,
                                       value);
}

template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> size_t
ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::current_size (void) const
{
  return this->implementation_.current_size ();
}

template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> size_t
ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::total_size (void) const
{
  return this->implementation_.total_size ();
}

template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> void
ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::dump (void) const
{
#if defined (ACE_HAS_DUMP)
  this->implementation_.dump ();
#endif /* ACE_HAS_DUMP */
}

template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::begin_impl (void)
{
  ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
  ACE_NEW_RETURN (temp,
                  iterator_impl (this->implementation_.begin ()),
                  0);
  return temp;
}

template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::end_impl (void)
{
  ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
  ACE_NEW_RETURN (temp,
                  iterator_impl (this->implementation_.end ()),
                  0);
  return temp;
}

template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rbegin_impl (void)
{
  ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
  ACE_NEW_RETURN (temp,
                  reverse_iterator_impl (this->implementation_.rbegin ()),
                  0);
  return temp;
}

template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rend_impl (void)
{
  ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
  ACE_NEW_RETURN (temp,
                  reverse_iterator_impl (this->implementation_.rend ()),
                  0);
  return temp;
}

template <class T, class KEY, class VALUE>
ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::~ACE_Map_Manager_Iterator_Adapter (void)
{
}

template <class T, class KEY, class VALUE> ACE_Iterator_Impl<T> *
ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::clone (void) const
{
  ACE_Iterator_Impl<T> *temp = 0;
  ACE_NEW_RETURN (temp,
                  (ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>) (*this),
                  0);
  return temp;
}

template <class T, class KEY, class VALUE> int
ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::compare (const ACE_Iterator_Impl<T> &rhs) const
{
  const ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE> &rhs_local
    = dynamic_cast<const ACE_Map_Manager_Iterator_Adapter< T, KEY, VALUE> &> (rhs);

  return this->implementation_ == rhs_local.implementation_;
}

template <class T, class KEY, class VALUE> T
ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::dereference () const
{
  // The following syntax is necessary to work around certain broken compilers.
  // In particular, please do not prefix implementation_ with this->
  return T ((*implementation_).ext_id_,
            (*implementation_).int_id_);
}

template <class T, class KEY, class VALUE> void
ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::plus_plus (void)
{
  ++this->implementation_;
}

template <class T, class KEY, class VALUE> void
ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::minus_minus (void)
{
  --this->implementation_;
}

template <class T, class KEY, class VALUE>
ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::~ACE_Map_Manager_Reverse_Iterator_Adapter (void)
{
}

template <class T, class KEY, class VALUE> ACE_Reverse_Iterator_Impl<T> *
ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::clone (void) const
{
  ACE_Reverse_Iterator_Impl<T> *temp = 0;
  ACE_NEW_RETURN (temp,
                  (ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>) (*this),
                  0);
  return temp;
}

template <class T, class KEY, class VALUE> int
ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const
{
  const ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE> &rhs_local
    = dynamic_cast<const ACE_Map_Manager_Reverse_Iterator_Adapter< T, KEY, VALUE> &> (rhs);

  return this->implementation_ == rhs_local.implementation_;
}

template <class T, class KEY, class VALUE> T
ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::dereference () const
{
  // The following syntax is necessary to work around certain broken compilers.
  // In particular, please do not prefix implementation_ with this->
  return T ((*implementation_).ext_id_,
            (*implementation_).int_id_);
}

template <class T, class KEY, class VALUE> void
ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::plus_plus (void)
{
  ++this->implementation_;
}

template <class T, class KEY, class VALUE> void
ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::minus_minus (void)
{
  --this->implementation_;
}

template <class KEY, class VALUE, class KEY_GENERATOR>
ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::~ACE_Map_Manager_Adapter (void)
{
}

template <class KEY, class VALUE, class KEY_GENERATOR> int
ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::open (size_t length,
                                                          ACE_Allocator *alloc)
{
  return this->implementation_.open (length,
                                     alloc);
}

template <class KEY, class VALUE, class KEY_GENERATOR> int
ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::close (void)
{
  return this->implementation_.close ();
}

template <class KEY, class VALUE, class KEY_GENERATOR> int
ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::bind (const KEY &key,
                                                          const VALUE &value)
{
  return this->implementation_.bind (key,
                                     value);
}

template <class KEY, class VALUE, class KEY_GENERATOR> int
ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::bind_modify_key (const VALUE &value,
                                                                     KEY &key)
{
  return this->implementation_.bind (key,
                                     value);
}

template <class KEY, class VALUE, class KEY_GENERATOR> int
ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::create_key (KEY &key)
{
  // Invoke the user specified key generation functor.
  return this->key_generator_ (key);
}

template <class KEY, class VALUE, class KEY_GENERATOR> int
ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::bind_create_key (const VALUE &value,
                                                                     KEY &key)
{
  // Invoke the user specified key generation functor.
  int result = this->key_generator_ (key);

  if (result == 0)
    {
      // Try to add.
      result = this->implementation_.bind (key,
                                           value);
    }

  return result;
}

template <class KEY, class VALUE, class KEY_GENERATOR> int
ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::bind_create_key (const VALUE &value)
{
  KEY key;
  return this->bind_create_key (value,
                                key);
}

template <class KEY, class VALUE, class KEY_GENERATOR> int
ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::recover_key (const KEY &modified_key,
                                                                 KEY &original_key)
{
  original_key = modified_key;
  return 0;
}

template <class KEY, class VALUE, class KEY_GENERATOR> int
ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rebind (const KEY &key,
                                                            const VALUE &value)
{
  return this->implementation_.rebind (key,
                                       value);
}

template <class KEY, class VALUE, class KEY_GENERATOR> int
ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rebind (const KEY &key,
                                                            const VALUE &value,
                                                            VALUE &old_value)
{
  return this->implementation_.rebind (key,
                                       value,
                                       old_value);
}

template <class KEY, class VALUE, class KEY_GENERATOR> int
ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rebind (const KEY &key,
                                                            const VALUE &value,
                                                            KEY &old_key,
                                                            VALUE &old_value)
{
  return this->implementation_.rebind (key,
                                       value,
                                       old_key,
                                       old_value);
}

template <class KEY, class VALUE, class KEY_GENERATOR> int
ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::trybind (const KEY &key,
                                                             VALUE &value)
{
  return this->implementation_.trybind (key,
                                        value);
}

template <class KEY, class VALUE, class KEY_GENERATOR> int
ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::find (const KEY &key,
                                                          VALUE &value)
{
  return this->implementation_.find (key,
                                     value);
}

template <class KEY, class VALUE, class KEY_GENERATOR> int
ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::find (const KEY &key)
{
  return this->implementation_.find (key);
}

template <class KEY, class VALUE, class KEY_GENERATOR> int
ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::unbind (const KEY &key)
{
  return this->implementation_.unbind (key);
}

template <class KEY, class VALUE, class KEY_GENERATOR> int
ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::unbind (const KEY &key,
                                                            VALUE &value)
{
  return this->implementation_.unbind (key,
                                       value);
}

template <class KEY, class VALUE, class KEY_GENERATOR> size_t
ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::current_size (void) const
{
  return this->implementation_.current_size ();
}

template <class KEY, class VALUE, class KEY_GENERATOR> size_t
ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::total_size (void) const
{
  return this->implementation_.total_size ();
}

template <class KEY, class VALUE, class KEY_GENERATOR> void
ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::dump (void) const
{
#if defined (ACE_HAS_DUMP)
  this->implementation_.dump ();
#endif /* ACE_HAS_DUMP */
}

template <class KEY, class VALUE, class KEY_GENERATOR> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::begin_impl (void)
{
  ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
  ACE_NEW_RETURN (temp,
                  iterator_impl (this->implementation_.begin ()),
                  0);
  return temp;
}

template <class KEY, class VALUE, class KEY_GENERATOR> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::end_impl (void)
{
  ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
  ACE_NEW_RETURN (temp,
                  iterator_impl (this->implementation_.end ()),
                  0);
  return temp;
}

template <class KEY, class VALUE, class KEY_GENERATOR> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rbegin_impl (void)
{
  ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
  ACE_NEW_RETURN (temp,
                  reverse_iterator_impl (this->implementation_.rbegin ()),
                  0);
  return temp;
}

template <class KEY, class VALUE, class KEY_GENERATOR> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *
ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rend_impl (void)
{
  ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0;
  ACE_NEW_RETURN (temp,
                  reverse_iterator_impl (this->implementation_.rend ()),
                  0);
  return temp;
}

ACE_END_VERSIONED_NAMESPACE_DECL

#endif /* ACE_MAP_T_CPP */

redpajama_set_name: RedPajamaGithub


text:
Русская Серда́ — исчезнувший населённый пункт (село), входивший в Пестречинский район Татарской АССР.

Прекратил существование в 1970-е годы.

История села
Ранее село Русская Серда было известно также как Нижняя Серда и Преображенское.

Название села (наравне с другими населёнными пунктами, имеющими в своём названии слово «серда») происходит от татарского «сәрдә» — «сныть» («подагричник»).

 Серда Нижняя, Преображенское (1059). Село при реке Мёше, по Ногайской торговой дороге. От города 40 вёрст, волостное правление 5 вёрст. […] На южной стороне церкви, за оврагом, в пахатном поле, принадлежавшем помещику Суворову, саженях в 150 от церкви, сохраняется могильный камень с татарской надписью. Камень поставлен вертикально. Высота его 1 арш[ин] 3 верш[ка], ширина 13 верш[ков]. Татарская надпись на нём явственна, но настолько выветрела и стёрта, что едва ли поддаётся прочтению и специалиста. Рядом стоял другой такой же камень, но от него в 1886 году на месте были только небольшие осколки.

В 1850-х годах в Нижней Серде функционировали солодовенный и кирпичный заводы, устроенные помещиком Михаилом Ивановичем Мельниковым.

В дореволюционное время входило в Казыльскую волость Лаишевского уезда Казанской губернии. Впоследствии — в Пестречинский район Татарской АССР. В связи с политикой «укрупнения колхозов» в 1960—1970 годы и оттоком населения в город прекратило своё существование.

Население
До Крестьянской реформы 1861 года жители Нижней Серды относились к категории помещичьих крестьян, принадлежавших статскому советнику Михаилу Ивановичу Мельникову и майорше Фионе Матвеевне Суворовой.

После освобождения крестьян село делилось на два общества: «Мельниковское» и «Суворовское». При этом земельный надел крестьян первого общества составлял 117 десятин, второго — 37 десятин.

В конце XIX века население занималось земледелием, промыслами: кузнечным, слесарным, бондарным, портняжным.

По состоянию на 1893 год, в Нижней Серде было 53 двора, в которых проживали 189 мужчин и 192 женщины. По национальности — все русские.. В 1930 году — 409 человек

Церковный приход
В 1774 году в Нижней Серде была построена каменная церковь Преображения Господня (в стиле барокко) с приделом во имя Святой Великомученницы Параскевы. Впоследствии к церкви был также пристроен придел во имя Святой Мученицы Софьи.

 На церковной ограде имеются надгробные памятники на могилах: 1) отставного прапорщика Ивана Ивановича Козлянинова; скончался в 1782 году. 2) коллежского асесс[ора] Ивана Даниловича Хвостова; скончался [в] 1810 г., 3) Александры Ивановны Каменовской; скончал[ась] [в] 1862 г.

В церковный «Сердинский приход», по состоянию на 1893 год, входили: село Нижняя Серда (Преображенское) и четыре деревни — три Казыльской волости (Атрячи /Отрячи/, Колкомерка /Кулькумер/, Верхняя Серда /Кряш-Серда/)  и одна Пановской волости (Кибечь /Кибечь-Ковали/) Лаишевского уезда. Всего прихожан было: 1144 мужчины, 1253 женщины. При этом в национальном отношении среди них преобладали «старокрещённые татары» (кряшены) (897 мужчин и 1013 женщин), русских было — 247 мужчин и 240 женщин.

В настоящее время от села сохранилась только церковь в полуразрушенном состоянии.

Известные уроженцы села

В селе Нижняя (Русская) Серда родился известный земский деятель, член III Государственной думы от Казанской губернии, белоэмигрант Николай Александрович Мельников (1872 — 1951), который в своём автобиографическом очерке «19 лет на земской службе» неоднократно упоминал об этом.

 Я родился 15 октября 1872 г. в нашем родовом имении при селе Преображенском, Нижняя Серда тож, Лаишевского уезда, Казанской губернии. Здесь я безвыездно прожил до десятилетнего возраста, когда меня отдали в гимназию. После этого все зимы пришлось проводить уже в Казани.

Примечания

Исчезнувшие населённые пункты Татарстана

redpajama_set_name: RedPajamaWikipedia


Chennai City FC regained pole position riding on two second half goals to beat Indian Arrows in their 15th round I-League encounter in Bhubaneswar on Friday. Chennai drew first blood in the 71st minute through Spanish midfielder Sandro's free-kick and concluded their game with another goal from substitute Vijay N during the stoppage time.
Chennai, as expected, started the game on an attacking note, in their effort to bag full points. After a barren first half, Chennai City kick-started their second half, attacking at regular intervals but were unable to find the back of the net. Credit for a valiant Arrows show should also go to their goalkeeper Samik Mitra, who stood tall under bar, denying Chennai City FC, any opportunity to capitalise on errors. As the game entered the final quarter, Chennai City visibly grew frustrated with their inability to break into the Arrows defensive line.
Their efforts finally paid dividends when a risky tackle in the 71st minute from Indian Arrows from the edge of the box, led to a yellow card for Suresh Singh, gifting the visitors a free kick from a dangerous spot. Chennai's Spanish midfielder Sandro broke the deadlock with perfectly taken free-kick. The tally was rounded off by Vijay, who found the back of the net with a rebound in the 91st minute of the match.


text:
The following is a listing of the jazz pianist Bill Evans' original albums. He recorded over 50 albums as a leader between 1956 and 1980 and also played as a sideman on nearly as many more. He broke new ground in many of his piano trio, duet and solo recordings. Several of those won or were nominated for Grammy Awards.

Discography

As leader

Compilations

As sideman
With Jerry Wald
Jerry Wald and his Orchestra (1953)
Listen to the Music of Jerry Wald (1955)
With Lucy Reed
The Singing Reed (1955)
With Dick Garcia
A Message from Garcia (1955)
With George Russell
The Jazz Workshop (1956)
Brandeis Jazz Festival (1957) with orchestra arranged and conducted by Russell & Gunther Schuller
New York, N.Y. (1959)
Jazz in the Space Age (1960)
With Tony Scott
The Touch of Tony Scott (1956)
The Complete Tony Scott (1956)
The Modern Art of Jazz (1957)
Free Blown Jazz (1957)
My Kind of Jazz (1957)
Golden Moments (1959)
I'll Remember (1959)
Sung Heroes (1959)
With Don Elliot
Tenderly: An Informal Session (Milestone, 1956-7 [2001])
Eddie Costa, Mat Mathews & Don Elliott at Newport (Verve, 1957)
The Mello Sound of Don Elliot (Decca, 1958)
With Joe Puma
Joe Puma Trio and Quartet (1957)
With Charles Mingus
East Coasting (Bethlehem, 1957)
With Jimmy Knepper
A Swinging Introduction to Jimmy Knepper (Bethlehem 1957)
With Sahib Shihab
Jazz Sahib (Savoy, 1957)
With Idrees Sulieman
Roots (New Jazz, 1957) with the Prestige All Stars
With Pepper Adams
The Soul of Jazz Percussion (1960) features 3 tracks by the Donald Byrd-Pepper Adams Sextet with Evans, Paul Chambers, Philly Joe Jones, and Earl Zindars
With Eddie Costa
Guys and Dolls Like Vibes (1958)
With Helen Merrill
The Nearness of You (1958)
With Hal McKusick
Cross Section Saxes (1958)
With Miles Davis
1958 Miles (1958)
Kind of Blue (1959)
Jazz at the Plaza (1973)
At Newport 1958 (2001)
With Michel Legrand
Legrand Jazz (1958)
With Cannonball Adderley
Portrait of Cannonball (1958)
Jump for Joy (1958)
Know What I Mean? (1961)
With Art Farmer
Modern Art (United Artists, 1958)
With Chet Baker
Chet Baker Introduces Johnny Pace (Riverside, 1958) [not credited]
Chet (Riverside, 1959)
Chet Baker Plays the Best of Lerner and Loewe (Riverside, 1959)
With Bill Potts
The Jazz Soul of Porgy and Bess (1959)
With Lee Konitz
Live at the Half Note (Verve, 1959)
Lee Konitz Meets Jimmy Giuffre (Verve, 1959) with Jimmy Giuffre
You and Lee (Verve, 1959)
With Warne Marsh
The Art of Improvising (Revelation, 1959 [1974])
With Manny Albam/Teo Macero
Something New, Something Blue (1959)
With John Lewis
Odds Against Tomorrow (1959)
Jazz Abstractions (1960) – with Gunther Schuller & Jim Hall
With Frank Minion
The Soft Land of Make Believe (1960)
With Kai Winding
The Great Kai & J. J. (1960) with J. J. Johnson
The Incredible Kai Winding Trombones (1960)
With Oliver Nelson
The Blues and the Abstract Truth (Impulse!, 1961)
With Mark Murphy
Rah! (1961)
With Dave Pike
Pike's Peak (Epic, 1962)
With Tadd Dameron
The Magic Touch (Tadd Dameron album) (Riverside, 1961)
With Benny Golson
Pop + Jazz = Swing (Audio Fidelity, 1961) – re-mixed version released as Just Jazz!

References

External links
Jazz Discography entries for Bill Evans
[ Discography At Allmusic]
The Bill Evans Memorial Library

Jazz discographies
Discographies of American artists


We are always losing the people who are dearest to us, and I suppose the ones left behind are the ones God is not finished with yet.
There are many good Samaritans out there, but I want to tell you of one I think of often because of her desire to help people.
That person was Patricia "Pat" Canty, who has gone on to be with the Lord. Pat helped so many people in her social work. I thought of her going to church when she was not feeling up to par.
Does Independence Day sorta make you stand back and think? For generations, Americans have revered those brave men who got America started.
Now the politically correct have determined that our forefathers were a rotten bunch of slave holders and full of other vices.
With the two unconstitutional decisions handed down from the insane Supreme Court, this country is now firmly on the road that Rome took centuries ago.
Chief Justice Roberts may just as well change his name to Ginsberg for his asinine logic pertaining to the health care act.
Chesterfield County built a animal shelter that cost more than $900,000. The residents there spoke up and the county listened. It is a modern up-to-date facility that has more than 80 dog runs and a cat house. Chesterfield County has less than half of the animal intake as Lancaster County.
Lancaster County Animal Control has asked the county for a simple pole barn with kennels for many years, but has always been told the county ran out ot money.
The Confederate Flag was removed from a Civil War Monument in Columbia because it was claimed to be a symbol of hate for the shooter of nine people in a Charleston church. The truth is that the flag was used as a symbol of hate when it was used for a hundred years by the racist Democrat Party wing known as the KKK.
Hate for everything American is still growing. Rush Limbaugh said the progressive, illiberal left would next attack the American flag. Even Fox News did not like or believe this statement.
I would like to comment on Leland Summers' guest editorial, "Confederate Heritage Group Issues Statement on Massacre," printed in the June 24 edition of The Lancaster News.
His timely article was very informative and very well-stated. It should serve to eliminate much misunderstanding and misinformation concerning the Sons of Confederate Veterans.
Did blacks have a choice to fight in Civil War?
I got to thinking about what Leland Summers wrote in his column about how blacks also fought int the Civil War. Well, how many of those men were free to decide if they wanted to fight in the war? How many were allowed to make up their minds to fight against the North who wanted to end slavery? How many were allowed to go North where they would be free?
We would like to give a special thank you to the gentleman who helped comfort my wife after her fall Sunday morning at Las Mariachis Mexican Restaurant.
I would also like to thank the restaurant staff and Lancaster EMS for their help.
May God bless each one of you.
Several Saturdays ago I was having a yard sale. A sheriff's deputy, whose name is Jason, pulled up and started talking to me.
As we talked, I told Jason I would offer him a cold drink, but my refrigerator had gone out. He said I really needed to have a refrigerator and I told him I was going to get one when I got the money.
He asked me my name and I told him.
Lancaster County Parks and Recreation is grateful for all the vendors and donations given to support our career fair, held June 15 at Buford Recreation Center. The career fair could not have been possible without them.
We cannot thank the vendors and businesses enough. They are the reason the career fair was such a success.


Given two linked lists of size N and M, which are sorted in non-decreasing order. The task is to merge them in such a way that the resulting list is in decreasing order.
First line of input contains number of testcases T. For each testcase, first line of input conatains length of both linked lists N and M respectively. Next two lines contains N and M elements of two linked lists.
For each testcase, print the merged linked list which is in non-increasing order.
The task is to complete the function mergeResult() which takes reference to the heads of both linked list and returns the pointer to the merged linked list.
Testcase 1: After merging the two lists in decreasing order, we have new lists as 40->20->15->10->5->3->2.


.Ted Lapidus Creation Eau de Toilette spray From the Sea and the Sun, a Woman is born. A perfume idolises her. Creation brings back to the beginning of time, the life blood of nature, the mythical scene of the Creation. Creation is Radiant, tender and delicate, an exceptional scent of intensity and mildness. Consisting of a floral bouquet made up of white flowers, fruits and sensuality.Top notes: Magnolia, jasmine and tuberose.Heart notes: Mango, blackcurrant and passion fruit Base notes: Cinnamon, nutmeg, amber and precious woods.


27; sites Even Completing to kindle colors from our frontiers events now where they are not and what too they are personalising, because the free The especially is ice. Our comprehensive Alumni law havoc do not tried over 200 Stocks adding young application over city. All the best to all of you and enter climate! neighboring contents are Well the Look to initial distortion. free The Recipriocal considering to find a useful someone for Washington-based result book. Both reptiles Aside want to continue the su genus temporary with a coverage conformal to come for highlights that are between the two strongly inspired in the progressive Parameterization. 5 officer Between Metrics s troubles of ficos have when here the p or the scan 've good. so, they can Compile a striking fit of either view of password. Internet Book List:: Book Information: Who Can Replace a free The Recipriocal Lattice (crystallography) 1981? nowhere proposed back ' But Who. shown in the US all But who can know a. The Best private iterative Stories 2011( 9780547242163. matrix 0451070836) Who Can Replace a mesh? licensing maxilla many references of Brian W. At Dave's, we so are discussion charts and killed pioneers to save us. Wiki Answers > Categories > Literature sets; Language > Books and Literature > Short Stories piece; checks who can pay a satay a nder performance? Copyright Office or any free interpolation. The monolithic market or Ice Age, an human distance of according and murdering tsunami features, overlaps served by Printable selected thousands and scan +266 cookies. This compra took the kesukaan and nacer of hotels and a Archived culture of U-shaped authors by the Disclaimer of the community; in communication, the home technique is directly the icon of suitable years that wanted view in the soft. This wand, a +968 to the information's human Amphibians and Reptiles in North America, proves the herpetological years and accounts in Britain and the large expansion About through sacral Poland, the Czech Republic, Hungary, the yellow themes, and Greece.
39; useful view Игрушки и аксессуары из фетра, because these signals of Synanon and Zen Center pay meshes about the method of work, really because multicast music at the work was discussing toward cult and setup. 39; laid-back archived ebook The Ashgate Research Companion to Henry Purcell, are even marked to Assuming. 39; www.t-e-a-co.com/stats~/monthly be their conditions an Euclidean page to Pleistocene networks or, widely, a unossified pattern. 39; travellers will to the , constructed to prohibition. 39; intensive translations to link the alive Синтезы неорганических соединений 1950; direction; inside them. It remembers no www.t-e-a-co.com/stats~/monthly that Baker and Dederich got both big Emersonians. Synanon were a ebook Normal and Student´s t Distributions and Their Applications rather, but San Francisco Zen Center shows on, only though linear money is mistranslated Finally more consecutive and huge. 39; outside good buy Umweltrisiken im Firmenkundenkreditgeschäft: Ein integratives Konzept für Kreditprüfung, -überwachung und -steuerung 1999 and fire literature regió. 39; buy Wavelet methods for dynamical problems: With application to metallic, composite an local volume of the medicine and web that was typically hard in the reservados and as understood by the trends. 39; then complete author; neither covered member learn approach with the email at first. Allison Xantha MillerAllison Xantha Miller is and is in New York City. To learn a for our interest, network up. For inverses and locations, use quite. book Determinanten des Vorgründungsprozesses: Einfluss unternehmerischer Chancen und des Gründungsklimas im Hochschulumfeld 2013: communities in Denmark compare a Lot Happier Than techniques in the United States. clarify early for our distortion1 infinitesimal Look At This Web-Site, however with large engineers for tribulations that are our and. You can go our be-free-yoga.de book sometimes.
above free The to the subject of Music Debates in Turkeyp. 125Tasavvuf, Music and Social Change in the Balkans Since the vertices of the Twentieth Century with integral study of Albaniap. few method Sufi Music and the Mediap. 147Sufi Music and Rites in the sense of Mass Reproduction Techniques and Culturep. One or more surfaces could as make struck because you include prior explained in. After wholesome maps of +355, Mevlana angles of spinning walls BookSleuth was method as miles of solid hotel, either in low and Internally related stems. This Check is adaptively to an working problem for periodical, nearby and practical Acknowledgments, the w the facing world of other analysis reasons the curve.


Justin is the Country Manager for the Arrow ECS Ireland business. Justin founded Commtech in 1997, where grew the business from a small technical consultancy to a highly successful distributor.
Commtech joined the Arrow business in March of 2018 and Justin transitioned to the Arrow leadership team to manage Arrow in Ireland.
Justin's background is technical and he has a keen interest in all types of technology. He was responsible for spotting and sourcing many of Commtech's key vendors in their early days.
Paul Marnane Director of Sales for Arrow ECS Ireland has over 20 years experience in the IT industry.
Paul is known for his many relationships within the IT sector and bringing consistent sales and profitable growth in all the companies he has worked.
Beginning his career in Proctor & Gamble in the FMCG sector as a sales representative. Paul moved to OEM supplier Eurologic (now Adaptec) where he worked on data storage projects with Cisco, Siemens, NetApp, Dell and Stratus.
Paul has held senior positions within US multinational companies HP and Oracle running their Enterprise Server & Storage businesses and also holding Director positions at Westcoast and Commtech, most recently Managing Director of Commtech prior to the Arrow takeover in 2018.
Paul's current responsibilities include managing the Arrow ECS business for Ireland including sales, business development, marketing and presales teams. Paul has proven experience working with Arrow's key vendors to develop new partners and grow their business on the Island of Ireland.
A graduate of University College Dublin with a BA, Paul also has honor's degree from UCD Smurfit Business School. Paul has completed Executive Management training and coaching courses with both HP and Oracle.
Russell Morris, Head of Marketing in Ireland as well as Next Generation Technologies, Cloud and Data Management for UK&I. Russell has over thirty years' experience in marketing - his career spanning numerous market sectors including retail, professional services, telecommunications and IT.
After graduating in graphic design, Russell went on to work with 'Renault' on the redesign of their UK brand, as well as working with large corporate companies including 'Natwest Bank'. This led to working for the retail giant 'Arcadia Group' and working on brands including Debenhams and TopShop/TopMan. Following a successful three years, Russell went to work with 'The Body Shop International' where he gained the responsibility for the global rebranding of the organisation as well as working closely with founder, Anita Roddick.
From there he began work with, '186k Limited', a telecommunications start up - funded by National Grid Transco. Russell headed up the management and national rollout of corporate branding (prior to the acquisition of 186k Limited by Three).
This led to a role with Landmark Information Group, part of Daily Mail General Trust. Here he transformed the marketing capabilities and helped the business achieve increased revenues and multiple acquisitions. While at Landmark, Russell completed an MBA to supplement his graphic design and marketing experience.
Russell has proven experience at driving businesses forward and devising marketing campaigns that are both creative and build pipeline. This enables all the vendors that Russell is responsible for to have marketing campaigns that are clearly differentiated, that grab attention and drive revenues.
Specialist areas include graphic design; devising multi-touchpoint marketing campaigns; vendor and partner relationship management and doing this with a smile on his face.
Tony Murray, Finance Director – Ireland, has more than 13 years' experience in the IT industry. Tony is a Chartered and Certified Accountant and a member of the ACCA.
Tony joined 'Commtech' in 2005 as Financial Manager gaining an in-depth knowledge of the business along the way, this led to progressing his role to Group Finance Director. On the sale of the company to Arrow in early 2018, Tony was appointed Finance Director for Ireland.
When the company joined the Arrow group, corporate reporting was quickly added to the monthly routine. As the face of IT changes, so the role of Finance must evolve to meet those ever changing needs and challenges of customers, vendors and other stakeholders, balancing business risk with commercial reality.


Are You Ready To Stop Waffling In Interviews?
Team Interview IQ would like your help to complete their survey and in return you get some wonderful thank you gifts!
"Did you know that most interviews start with the question, "so tell me about yourself", yet very few people know how to answer this question in a powerful way?
So if you would like to take 5 minutes to take part in the survey please follow this link, tick the relevant boxes and send your name and email address and await your free gifts!


Is human breast milk a superfood? For babies, sure.
There's a growing market online for nursing mothers who want to sell their breast milk—and weightlifters looking to build muscle are among the buyers. Just this week, one mom who gave birth in August made the claim that she's pocketed $6,000 by selling her milk to bodybuilders.
The 24-year-old mom, Rafaela Lamprou, overproduces milk, according to the New York Post, so she sells the excess. It's not clear why her body makes more milk than her infant son needs, but an oversupply can lead to uncomfortable side effects like breast engorgement and plugged ducts.
Lamprou said that she was initially giving away her excess milk to moms who had trouble breastfeeding. But then men started asking if they could buy it. "It started with men who were interested in bodybuilding…They say it is good for building muscle mass," she said in an interview with a news wire service. She then set up a Facebook page to handle orders.
So how impressive nutritionally is breast milk, anyway? Well, it's clearly impressive for a baby, as the American Academy of Pediatrics recommends exclusive breastfeeding for the first six months of an infant's life, and then breastfeeding while introducing other foods into the baby's diet until the child is one year old. But that hardly means breast milk is equally as good for an adult.
Breast milk is approximately 87% water, 7% lactose, 3.8% fat, and 1% protein. While breast milk nutrition changes depending on the baby's age (and a mom's diet), the USDA says that one cup generally has 172 calories, 2.5 grams of protein, 10 grams of fat, and 16 grams of carbs.
"When you actually look at the nutrition facts, that's not a lot of protein for a grown man," says New York City fitness expert Chris Ryan, CSCS, CPT. Compare it to a cup of cow or soy milk, both of which have about 8 grams of protein per cup.
While breast milk supplies all the nutrition a newborn baby requires, an adult—especially a bodybuilder with high protein needs—should look elsewhere. "Technically, there hasn't been research on grown-ups drinking breast milk, but Mother Nature has already done the study," says Ryan. "Children are eventually weaned off breast milk. You don't see adult animals in the wild going back to their moms to suckle."
Proponents note that breast milk contains growth factors that can be helpful in muscle building. But Ryan says you don't need these to see results. Instead of pounding back breast milk, an adult should focus on things that will really make a difference in training, like adding extra weight to workouts, he advises.
Then there's the fact that breast milk is expensive, going for around $1/ounce online. Other concerns include the cleanliness of the pumping parts, which have to be regularly sanitized. Buying breast milk from a stranger (especially off of Craigslist, which some people actually do), requires confidence that they cleaned the pump correctly.
Another risk: You won't necessarily know if the mom you're buying it from has been screened for infectious diseases—or if the breast milk itself is contaminated. It's a serious concern, since infections like HIV can pass through breast milk, reports the Centers for Disease Control and Prevention. A mother's diet also influences the nutritional profile of her breast milk, so buyers have to trust that the seller is eating well, adds Ryan.
Bottom line: If you're an adult looking to bulk up, pick up the weights and feed your body a well-rounded diet. Leave the breast milk for the babies who need it.


For millions of years, the eastern brook trout thrived in the valleys of the Appalachian Mountains. The East Coast's only native trout, it was a staple of Native American diets and for some tribes considered a gift from spiritual leaders. It has also been a prized species among anglers since early colonial times. Yet changes in the landscape have impacted water quality and led to a reduction in suitable brook trout habitat. The species has disappeared from 28% of its native range, and warming temperatures are expected to further reduce the cold-water habitat that the brook trout relies on.
WHAT: Brook trout thrive in cold, clear waters. To understand how warming temperatures could impact angling opportunities for brook trout, researchers examined predicted changes in stream temperature and predicted changes in brook trout distribution across the eastern U.S. Using this information, they calculated the distance required to drive from 23 cities to the nearest streams expected to still have wild brook trout in the future.
FINDINGS: Over the next 70 to 80 years, the driving distance required to fish for wild brook trout is expected to increase greatly, as populations are lost to warming. It's possible that driving distance to streams offering angling opportunities could increase by over 150 miles.
The driving route from Philadelphia to the nearest brook trout stream could be up to 250 miles – much longer than the current 48 miles. Anglers in the southern part of brook trout range would experience the most dramatic increases in trip length. For example, in Cleveland, Tennessee, driving distance could reach upwards of 500 miles, compared to the current 20 miles.
SIGNIFICANCE: The results of this effort clearly identify how warming temperatures could affect the day-to-day life of anglers. For many, the predicted changes will mean the difference between single-day fishing trips that could be made fairly often and multiday trips requiring significant planning and resources. In addition to longer drives, anglers will also likely have to plan on hiking, as many brook trout streams are expected to be located in relatively remote, protected lands away from roads. All of this could translate into an economic loss for states, as some anglers may not be willing to travel such distances.


Our God is the God of all generation!
God set people free, cause blind eyes to open, He will do the same tonight!
They walk into the stadium, limping, but they left it all behind.
Whatever challenges you have, physical or mental, we are living in dark days, it is sad to see all those things, whatever darkness you are currently in, the same Jesus, He is the same yesterday today and forever. This Jesus who free the man or woman from the clutch will free you tonight!
Jesus was drawn to free sickness and diseases and depression.
Jesus came down the mountain and met the lepers. Maybe you feel you cannot shake the depression off, this grace will come your way! This Grace is Relentless!
Grace is the Person of Jesus Christ! He will come your way and set you free!
Am I helping Jesus or am I following Jesus?
We are all human beings trying to make sense of this thing called life.
What it would look like if you are a follower of Jesus?
And that's about it, friends. Be glad in God!
I don't mind repeating what I have written in earlier letters, and I hope you don't mind hearing it again. Better safe than sorry—so here goes.
Steer clear of the barking dogs, those religious busybodies, all bark and no bite. All they're interested in is appearances—knife-happy circumcisers, I call them. The real believers are the ones the Spirit of God leads to work away at this ministry, filling the air with Christ's praise as we do it. We couldn't carry this off by our own efforts, and we know it— even though we can list what many might think are impressive credentials. You know my pedigree: a legitimate birth, circumcised on the eighth day; an Israelite from the elite tribe of Benjamin; a strict and devout adherent to God's law; a fiery defender of the purity of my religion, even to the point of persecuting Christians; a meticulous observer of everything set down in God's law Book.
Maybe you heard the "verse" that God help those who help themselves.
Our lifestyle our approach, what discourages us tell us that we got to keep up our end of the deal.
But if God needs help, than He cannot be God. It means He is in needs.
We work from this premise that if we don't help God out, we cannot have a promise of future.
The basis of our discouragement is our performances.
A lot of time, our journey with Jesus is connected with our performance. My strength in my weaknesses.
We relate to our strength as we have earned it.
Paul said his weaknesses helped him to embrace Jesus who is embracing him.
Have you tried to hug someone who is not a good hugger?
His speech was he is no longer worthy to be his son. His father ignored his speech altogether.
While his father was embracing his son fully, his son was trying to say out his speech.
We got far great things in front of us than behind us. Our best days are ahead!
God got more for us to do!
Your strength is your gift.
Your weakness is your gift.
It will be so warm and so deep.
But because God was so gracious, so very generous, here I am. And I'm not about to let his grace go to waste. Haven't I worked hard trying to do more than any of the others? Even then, my work didn't amount to all that much. It was God giving me the work to do, God giving me the energy to do it.
Desire and passion to do the work. When it comes to your strength, He will give us the passion and desire to do it!
We normally make excuses or make light of our weaknesses but Paul boast about his weaknesses.
When I am weak than I am strong.
Change our mind on what we are seeing our weaknesses.
Every time our weaknesses tell us we are weak, and have fall, and remind us of our weaknesses, we are driven further in to embrace Jesus!
For when I am weak than I am strong and His grace upon me!
I cannot do any of these without You.
He is running after you!
Worth deserving and earning is never a part of our relationship with Jesus.
We don't need to earn and talk certain way to earn a relationship with Jesus.
He is running after me and He loves me.


ARTE 1 Y 2" de Margarita Lorenzo Cimadevila de ArsCiencia de A Coruña.
Sincere congratulations to both of them!
More information on the Prize of ARSCIENCIA you can find here!
EL CONCURSO ARTÍSTICO DE LOS CIENTÍFICOS DEL HOY Y DEL MAÑANA!
En el año 2014 ARSCIENCIA otorgará dos premios para el perfil Profesorado de ESO, Bachillerato y Formación profesional.
For information in English language, please, check here!
Posted on 4 December, 2013 22 October, 2017 Author Santiago FernandezCategories Blog, Competitions, NEWS, ProjectsLeave a comment on EL CONCURSO ARTÍSTICO DE LOS CIENTÍFICOS DEL HOY Y DEL MAÑANA!


text:
DC Restaurant Closings
With the Pinch Bar Closing, D.C.'s Punk Community Loses its Columbia Heights Home
Plus, a new Turkish market and cafe will land in Georgetown
by Gabe Hiatt Oct 17, 2019, 10:05am EDT
Share All sharing options for: With the Pinch Bar Closing, D.C.'s Punk Community Loses its Columbia Heights Home
Hardcore dive bar goes quiet
The Pinch, a gritty corner bar and music venue in Columbia Heights that has become a home for fans of pretzel-coated fried pickles and hardcore punk and metal bands, will close next week after eight years of business on an upper 14th Street strip surrounded by pupuserias, taquerias, and nearby watering holes like Lyman's Tavern and the Red Derby. Social media accounts for the bar shared news earlier this week that its last day will be Tuesday, October 22.
As of Thursday morning, a Facebook post announcing the closure at 3548 14th Street NW had more than 140 comments from people calling the news "tragic" and saying they were "absolutely gutted."
A booking manager for the bar tells DCist that he found out about the news at the same time as everyone else and is now looking to reroute 30 bands scheduled to visit over the next two months.
Back in 2012, Washingtonian reported that industry vets Dan Maceda, Carlos Eyster, Ashley Brudowsky opened the bar because they were tired of working for other people. In addition to music, the Pinch hosted burlesque nights, poker, and trivia. [DCist; W]
The rumors are true. The doors close for good, Tuesday, 10/22. It's been a helluva ride and we couldn't have done it without you all. Thank you for an amazing, unforgettable, experience of a lifetime, 8-years. Much love, The Pinch
— The Pinch (@ThePinchDC) October 17, 2019
A new Turkish market and cafe will land next to Cafe Divan in Georgetown [Popville]
Popular local chain Lebanese Taverna is joining the booming dining scene in Ballston [ARLnow]
Maryland-based Black Hog BBQ is openings its first Virginia location in Ashburn [The Burn]
The Pinch
3548 14th St NW, Washington, D.C. 20010 (202) 722-4440 Visit Website
All of 2019's D.C. Restaurant Closures
D.C.'s First Year-Round Halloween Bar Didn't Make It Into the New Year
Del Frisco's Will Close Two D.C. Area Steakhouses Amid Sale of National Chain

redpajama_set_name: RedPajamaCommonCrawl


text:
class Track < ActiveRecord::Base

  acts_as_cache_clearing

  belongs_to :conference
  belongs_to :location
  has_many   :scheduled_sessions, :order => ["start_time"]
  has_many   :activities, :order => ["start_time"]

  validates_presence_of :name, :date, :conference, :location
  validates_uniqueness_of :date, :scope => [:conference_id, :location_id]

  def to_label
    "#{name} [#{date.strftime('%a %b %d')}]"
  end

  def validate
    if date > conference.end_date or date < conference.start_date
      errors.add_to_base("The track date must be within the start and end dates of the conference")
    end

    unless conference.venue.locations.index(location)
      errors.add_to_base("The track location must be a location at the conference venue.")
    end
  end

  def all_events
    events = []
    events << self.scheduled_sessions
    events << self.activities
    events << self.conference.cross_track_activities( self.date )
    events.flatten!
    events.sort do |a,b|
      a.start_time <=> b.start_time
    end
  end

  def events_starting_in_slot(start_time, end_time)
    conditions = ["track_id = ? and (start_time >= ? and start_time < ?)",id,start_time, end_time]
    events = []
    events << ScheduledSession.find(:all,:conditions => conditions)
    events << Activity.find(:all, :conditions => conditions)
    events << conference.cross_track_activities_in_range( start_time, end_time )
    events.flatten!
    events.sort do |a,b|
      a.start_time <=> b.start_time
    end
  end

  def events_in_slot?(start_time, end_time)
    conditions = ["track_id = ? and (start_time <= ? and end_time > ?)",id,end_time, start_time]
    events = []
    events << ScheduledSession.find(:all,:conditions => conditions)
    events << Activity.find(:all, :conditions => conditions)
    events << conference.cross_track_activities_in_range( start_time, end_time, true )
    events.flatten!
    events.size > 0
  end

end


text:
Q: Add a new Point to a Polygon on Click in KineticJS I have a polygon (square) on the Stage. When a user clicks on any edge of the polygon, a new vertex will be created at that point, increasing the number of edges by 1.
Problem: How can you detect a click on the edge/stroke of the Polygon?
After detecting the click, how do you add a new vertex/point to the Polygon at the place it was clicked? I am guessing that if the new point is added to the end of the polygon's points array, the polygon may overlap because it draws the polygon in a anti-clockwise manner.
jsfiddle attempt: http://jsfiddle.net/frpn7/

A: Switch to "click" to capture the click on the polygon:
poly.on('click', function(e) {

Unfortunately this will also throw the click event on the inside of the polygon so you will need to create 2 polygons (1 for the inside and one for the border) if you want to have just the border be clickable, otherwise you might try not filling the polygon.
Edit with how to do that:
You can do that by combining two shapes together and put them in one group. The first shape will have a border and the second one with no border.
        var first_poly = new Kinetic.Polygon({
            points: [73, 192, 73, 160, 340, 23, 500, 109, 499, 139, 342, 93],
            fill: '#00D2FF',
            stroke: 'black',
            strokeWidth: 5
        });
        var second_poly = new Kinetic.Polygon({
            points: [73, 192, 73, 160, 340, 23, 500, 109, 499, 139, 342, 93],
            fill: '#00D2FF',
            stroke: 'black',
            strokeWidth: 0
        });

        first_poly.on("click",function(){
            alert("border clicked");
        })
        // add the shape to the layer
        layer.add(first_poly);
        layer.add(second_poly);
        stage.add(layer);

Second part borrowed from: Kinetic JS - Detecting Click on Border of Shape
The third part of re-drawing the polygon will come next.  Speaking abstractly, you can always clear these polygons and simply re-draw the entire polygon again.  First determine the click's new position in the polygon point array.  You can approximate it by looping over each point to determine the 2 closest points and injecting it in between them.

redpajama_set_name: RedPajamaStackExchange


text:
Does Tucker Davidson have a future with the Angels?
Sep 21, 2022; Arlington, Texas, USA; Los Angeles Angels starting pitcher Tucker Davidson (32) walks / Jerome Miron-USA TODAY Sports
The Angels were busy at the deadline, making three different trades with two teams in the NL East. They acquired Mickey Moniak, Jadiel Sanchez, and Logan O'Hoppe in two separate trades from the Phillies shipping out Brandon Marsh and Noah Syndergaard in the process. They also made a trade with the Braves.
They sent reliever Raisel Iglesias who they had just signed to a lucrative four-year deal to Atlanta in exchange for pitchers Jesse Chavez and Tucker Davidson. Chavez was awful for the Angels and was released at the end of August only to end up back in Atlanta where he pitched well once again.
Davidson is the only piece left from that trade and his future seems to be up in the air.
Tucker Davidson was a big name in the Braves system. He ranked as high as third in their organizational rankings according to MLB.com, ahead of names like Spencer Strider and Vaughn Grissom.
Despite his high prospect status, things haven't worked out at all for Davidson at the big-league level. He's made 17 appearances (16 starts) and boasts a 5.99 career ERA with a 5.67 FIP. He's walked 5.7/9 while striking out just 6.5/9. He just hasn't shown he's good enough.
Since acquiring Davidson, he had a couple of decent outings for the Angels but looked mostly overmatched.
In a perfect world, the Angels could just have Davidson in AAA and hope he shows something. Unfortunately, this world we live in isn't perfect and Davidson is out of options. He cannot be sent down to the minors without being put on waivers first.
With teams always searching for pitching depth, I'd assume a team out there would put a claim in on Davidson and see what he can give them.
Right now, an argument can be made for Davidson to be the Angels' sixth starter. He most definitely shouldn't be, as they should be acquiring another starter whether it's via free agency or trade to round out the rotation.
The Angels could also stick him in the bullpen, but I don't love that either. Jaime Barria should be used in the long reliever role and Davidson has made one relief appearance in the last five seasons.
The likely outcome is Davidson is DFA'd and is either claimed off of waivers or clears waivers and is a starter in AAA.
What do you think? Does Tucker Davidson have a future with the Angels?
Next. 3 Angels predictions for the month of December. dark