active_object_map.cpp

来自「这是广泛使用的通信开源项目,对于大容量,高并发的通讯要求完全能够胜任,他广泛可用」· C++ 代码 · 共 1,161 行 · 第 1/3 页

CPP
1,161 行
字号
123
            }
        }
      else
        {
          this->active_object_map_->user_id_map_->unbind (entry->user_id_);
          delete entry;
        }
    }
  else
    delete entry;

  return result;
}

int
TAO_System_Id_With_Multiple_Id_Strategy::bind_using_system_id (PortableServer::Servant servant,
                                                               CORBA::Short priority,
                                                               TAO_Active_Object_Map::Map_Entry *&entry)
{
  ACE_NEW_RETURN (entry,
                  TAO_Active_Object_Map::Map_Entry,
                  -1);
  int result = this->active_object_map_->user_id_map_->bind_create_key (entry,
                                                                        entry->user_id_);
  if (result == 0)
    {
      entry->servant_ = servant;
      entry->priority_ = priority;

      result = this->active_object_map_->id_hint_strategy_->bind (*entry);

      if (result != 0)
        {
          this->active_object_map_->user_id_map_->unbind (entry->user_id_);
          delete entry;
        }
    }
  else
    delete entry;

  return result;
}

////////////////////////////////////////////////////////////////////////////////

TAO_Id_Hint_Strategy::~TAO_Id_Hint_Strategy (void)
{
}

////////////////////////////////////////////////////////////////////////////////

TAO_Active_Hint_Strategy::TAO_Active_Hint_Strategy (CORBA::ULong map_size)
  : system_id_map_ (map_size)
{
}

TAO_Active_Hint_Strategy::~TAO_Active_Hint_Strategy (void)
{
}

int
TAO_Active_Hint_Strategy::recover_key (const PortableServer::ObjectId &system_id,
                                       PortableServer::ObjectId &user_id)
{
  return this->system_id_map_.recover_key (system_id,
                                           user_id);
}

int
TAO_Active_Hint_Strategy::bind (TAO_Active_Object_Map::Map_Entry &entry)
{
  entry.system_id_ = entry.user_id_;

  return this->system_id_map_.bind_modify_key (&entry,
                                               entry.system_id_);
}

int
TAO_Active_Hint_Strategy::unbind (TAO_Active_Object_Map::Map_Entry &entry)
{
  return this->system_id_map_.unbind (entry.system_id_);
}

int
TAO_Active_Hint_Strategy::find (const PortableServer::ObjectId &system_id,
                                TAO_Active_Object_Map::Map_Entry *&entry)
{
  return this->system_id_map_.find (system_id,
                                    entry);
}

size_t
TAO_Active_Hint_Strategy::hint_size (void)
{
  return ACE_Active_Map_Manager_Key::size ();
}

int
TAO_Active_Hint_Strategy::system_id (PortableServer::ObjectId_out system_id,
                                     TAO_Active_Object_Map::Map_Entry &entry)
{
  ACE_NEW_RETURN (system_id,
                  PortableServer::ObjectId (entry.system_id_),
                  -1);
  return 0;
}

////////////////////////////////////////////////////////////////////////////////

TAO_No_Hint_Strategy::~TAO_No_Hint_Strategy (void)
{
}

int
TAO_No_Hint_Strategy::recover_key (const PortableServer::ObjectId &system_id,
                                   PortableServer::ObjectId &user_id)
{
  // Smartly copy all the data; <user_id does not own the data>.
  user_id.replace (system_id.maximum (),
                   system_id.length (),
                   ACE_const_cast (CORBA::Octet *,
                                   system_id.get_buffer ()),
                   0);

  return 0;
}

int
TAO_No_Hint_Strategy::bind (TAO_Active_Object_Map::Map_Entry &entry)
{
  ACE_UNUSED_ARG (entry);

  return 0;
}

int
TAO_No_Hint_Strategy::unbind (TAO_Active_Object_Map::Map_Entry &entry)
{
  ACE_UNUSED_ARG (entry);

  return 0;
}

int
TAO_No_Hint_Strategy::find (const PortableServer::ObjectId &system_id,
                            TAO_Active_Object_Map::Map_Entry *&entry)
{
  ACE_UNUSED_ARG (system_id);
  ACE_UNUSED_ARG (entry);

  return -1;
}

size_t
TAO_No_Hint_Strategy::hint_size (void)
{
  return 0;
}

int
TAO_No_Hint_Strategy::system_id (PortableServer::ObjectId_out system_id,
                                 TAO_Active_Object_Map::Map_Entry &entry)
{
  ACE_NEW_RETURN (system_id,
                  PortableServer::ObjectId (entry.user_id_),
                  -1);
  return 0;
}

////////////////////////////////////////////////////////////////////////////////

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)

template class auto_ptr<TAO_Id_Uniqueness_Strategy>;
template class auto_ptr<TAO_Lifespan_Strategy>;
template class auto_ptr<TAO_Id_Assignment_Strategy>;
template class auto_ptr<TAO_Id_Hint_Strategy>;
template class auto_ptr<TAO_Active_Object_Map::servant_map>;
template class auto_ptr<TAO_Active_Object_Map::user_id_map>;

#  if defined (ACE_LACKS_AUTO_PTR) \
      || !(defined (ACE_HAS_STANDARD_CPP_LIBRARY) \
           && (ACE_HAS_STANDARD_CPP_LIBRARY != 0))
template class ACE_Auto_Basic_Ptr<TAO_Id_Uniqueness_Strategy>;
template class ACE_Auto_Basic_Ptr<TAO_Lifespan_Strategy>;
template class ACE_Auto_Basic_Ptr<TAO_Id_Assignment_Strategy>;
template class ACE_Auto_Basic_Ptr<TAO_Id_Hint_Strategy>;
template class ACE_Auto_Basic_Ptr<TAO_Active_Object_Map::servant_map>;
template class ACE_Auto_Basic_Ptr<TAO_Active_Object_Map::user_id_map>;
#  endif  /* ACE_LACKS_AUTO_PTR */

// Common typedefs.
typedef PortableServer::ObjectId id;
typedef PortableServer::Servant servant;
typedef TAO_Active_Object_Map::Map_Entry *value;

typedef ACE_Pair<id, value> id_expanded_value;
typedef ACE_Reference_Pair<const id, value> id_value_type;
typedef ACE_Reference_Pair<const servant, value> servant_value_type;
typedef ACE_Equal_To<id> id_compare_keys;
typedef ACE_Equal_To<servant> servant_compare_keys;
typedef TAO_ObjectId_Hash id_hash;
typedef TAO_Servant_Hash servant_hash;
typedef ACE_Noop_Key_Generator<servant> noop_servant_key_generator;

template class ACE_Noop_Key_Generator<servant>;

// Common
template class ACE_Reference_Pair<const id, value>;
template class ACE_Reference_Pair<const servant, value>;

// Map and iterator classes.
template class ACE_Map<id, value>;
template class ACE_Map<servant, value>;
template class ACE_Iterator<id_value_type>;
template class ACE_Iterator<servant_value_type>;
template class ACE_Reverse_Iterator<id_value_type>;
template class ACE_Reverse_Iterator<servant_value_type>;

// Iterator base classes.
template class ACE_Iterator_Impl<id_value_type>;
template class ACE_Iterator_Impl<servant_value_type>;
template class ACE_Reverse_Iterator_Impl<id_value_type>;
template class ACE_Reverse_Iterator_Impl<servant_value_type>;

// Active Map Manager related.
template class ACE_Pair<id, value>;
template class ACE_Active_Map_Manager_Adapter<id, value, TAO_Ignore_Original_Key_Adapter>;
template class ACE_Active_Map_Manager_Adapter<id, value, TAO_Preserve_Original_Key_Adapter>;
template class ACE_Active_Map_Manager_Iterator_Adapter<id_value_type, id_expanded_value>;
template class ACE_Active_Map_Manager_Reverse_Iterator_Adapter<id_value_type, id_expanded_value>;
template class ACE_Active_Map_Manager<id_expanded_value>;
template class ACE_Map_Manager<ACE_Active_Map_Manager_Key, id_expanded_value, ACE_Null_Mutex>;
template class ACE_Map_Iterator_Base<ACE_Active_Map_Manager_Key, id_expanded_value, ACE_Null_Mutex>;
template class ACE_Map_Iterator<ACE_Active_Map_Manager_Key, id_expanded_value, ACE_Null_Mutex>;
template class ACE_Map_Reverse_Iterator<ACE_Active_Map_Manager_Key, id_expanded_value, ACE_Null_Mutex>;
template class ACE_Map_Entry<ACE_Active_Map_Manager_Key, id_expanded_value>;

// Hash Map Manager related.
template class ACE_Hash_Map_Manager_Ex_Adapter<id, value, id_hash, id_compare_keys, TAO_Incremental_Key_Generator>;
template class ACE_Hash_Map_Manager_Ex_Adapter<servant, value, servant_hash, servant_compare_keys, noop_servant_key_generator>;
template class ACE_Hash_Map_Manager_Ex_Iterator_Adapter<id_value_type, id, value, id_hash, id_compare_keys>;
template class ACE_Hash_Map_Manager_Ex_Iterator_Adapter<servant_value_type, servant, value, servant_hash, servant_compare_keys>;
template class ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<id_value_type, id, value, id_hash, id_compare_keys>;
template class ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<servant_value_type, servant, value, servant_hash, servant_compare_keys>;
template class ACE_Hash_Map_Manager_Ex<id, value, id_hash, id_compare_keys, ACE_Null_Mutex>;
template class ACE_Hash_Map_Manager_Ex<servant, value, servant_hash, servant_compare_keys, ACE_Null_Mutex>;
template class ACE_Hash_Map_Iterator_Base_Ex<id, value, id_hash, id_compare_keys, ACE_Null_Mutex>;
template class ACE_Hash_Map_Iterator_Base_Ex<servant, value, servant_hash, servant_compare_keys, ACE_Null_Mutex>;
template class ACE_Hash_Map_Iterator_Ex<id, value, id_hash, id_compare_keys, ACE_Null_Mutex>;
template class ACE_Hash_Map_Iterator_Ex<servant, value, servant_hash, servant_compare_keys, ACE_Null_Mutex>;
template class ACE_Hash_Map_Reverse_Iterator_Ex<id, value, id_hash, id_compare_keys, ACE_Null_Mutex>;
template class ACE_Hash_Map_Reverse_Iterator_Ex<servant, value, servant_hash, servant_compare_keys, ACE_Null_Mutex>;
template class ACE_Hash_Map_Entry<id, value>;
template class ACE_Hash_Map_Entry<servant, value>;
template class ACE_Equal_To<id>;
template class ACE_Equal_To<servant>;

#if (TAO_HAS_MINIMUM_POA_MAPS == 0)
// Map Manager related.
template class ACE_Map_Manager_Iterator_Adapter<id_value_type, id, value>;
template class ACE_Map_Manager_Iterator_Adapter<servant_value_type, servant, value>;
template class ACE_Map_Manager_Reverse_Iterator_Adapter<id_value_type, id, value>;
template class ACE_Map_Manager_Reverse_Iterator_Adapter<servant_value_type, servant, value>;
template class ACE_Map_Manager_Adapter<id, value, TAO_Incremental_Key_Generator>;
template class ACE_Map_Manager_Adapter<servant, value, noop_servant_key_generator>;
template class ACE_Map_Manager<id, value, ACE_Null_Mutex>;
template class ACE_Map_Manager<servant, value, ACE_Null_Mutex>;
template class ACE_Map_Iterator_Base<id, value, ACE_Null_Mutex>;
template class ACE_Map_Iterator_Base<servant, value, ACE_Null_Mutex>;
template class ACE_Map_Iterator<id, value, ACE_Null_Mutex>;
template class ACE_Map_Iterator<servant, value, ACE_Null_Mutex>;
template class ACE_Map_Reverse_Iterator<id, value, ACE_Null_Mutex>;
template class ACE_Map_Reverse_Iterator<servant, value, ACE_Null_Mutex>;
template class ACE_Map_Entry<id, value>;
template class ACE_Map_Entry<servant, value>;
#endif /* TAO_HAS_MINIMUM_POA_MAPS == 0 */

#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)

#pragma instantiate auto_ptr<TAO_Id_Uniqueness_Strategy>
#pragma instantiate auto_ptr<TAO_Lifespan_Strategy>
#pragma instantiate auto_ptr<TAO_Id_Assignment_Strategy>
#pragma instantiate auto_ptr<TAO_Id_Hint_Strategy>
#pragma instantiate auto_ptr<TAO_Active_Object_Map::servant_map>
#pragma instantiate auto_ptr<TAO_Active_Object_Map::user_id_map>

#  if defined (ACE_LACKS_AUTO_PTR) \
      || !(defined (ACE_HAS_STANDARD_CPP_LIBRARY) \
           && (ACE_HAS_STANDARD_CPP_LIBRARY != 0))
#    pragma instantiate ACE_Auto_Basic_Ptr<TAO_Id_Uniqueness_Strategy>
#    pragma instantiate ACE_Auto_Basic_Ptr<TAO_Lifespan_Strategy>
#    pragma instantiate ACE_Auto_Basic_Ptr<TAO_Id_Assignment_Strategy>
#    pragma instantiate ACE_Auto_Basic_Ptr<TAO_Id_Hint_Strategy>
#    pragma instantiate ACE_Auto_Basic_Ptr<TAO_Active_Object_Map::servant_map>
#    pragma instantiate ACE_Auto_Basic_Ptr<TAO_Active_Object_Map::user_id_map>
#  endif  /* ACE_LACKS_AUTO_PTR */

// Common typedefs.
typedef PortableServer::ObjectId id;
typedef PortableServer::Servant servant;
typedef TAO_Active_Object_Map::Map_Entry * value;

typedef ACE_Pair<id, value> id_expanded_value;
typedef ACE_Reference_Pair<const id, value> id_value_type;
typedef ACE_Reference_Pair<const servant, value> servant_value_type;
typedef ACE_Equal_To<id> id_compare_keys;
typedef ACE_Equal_To<servant> servant_compare_keys;
typedef TAO_ObjectId_Hash id_hash;
typedef TAO_Servant_Hash servant_hash;
typedef ACE_Noop_Key_Generator<servant> noop_servant_key_generator;

#pragma instantiate ACE_Noop_Key_Generator<servant>

// Common
#pragma instantiate ACE_Reference_Pair<const id, value>
#pragma instantiate ACE_Reference_Pair<const servant, value>

// Map and iterator classes.
#pragma instantiate ACE_Map<id, value>
#pragma instantiate ACE_Map<servant, value>
#pragma instantiate ACE_Iterator<id_value_type>
#pragma instantiate ACE_Iterator<servant_value_type>
#pragma instantiate ACE_Reverse_Iterator<id_value_type>
#pragma instantiate ACE_Reverse_Iterator<servant_value_type>

// Iterator base classes.
#pragma instantiate ACE_Iterator_Impl<id_value_type>
#pragma instantiate ACE_Iterator_Impl<servant_value_type>
#pragma instantiate ACE_Reverse_Iterator_Impl<id_value_type>
#pragma instantiate ACE_Reverse_Iterator_Impl<servant_value_type>

// Active Map Manager related.
#pragma instantiate ACE_Pair<id, value>
#pragma instantiate ACE_Active_Map_Manager_Adapter<id, value, TAO_Ignore_Original_Key_Adapter>
#pragma instantiate ACE_Active_Map_Manager_Adapter<id, value, TAO_Preserve_Original_Key_Adapter>
#pragma instantiate ACE_Active_Map_Manager_Iterator_Adapter<id_value_type, id_expanded_value>
#pragma instantiate ACE_Active_Map_Manager_Reverse_Iterator_Adapter<id_value_type, id_expanded_value>
#pragma instantiate ACE_Active_Map_Manager<id_expanded_value>
#pragma instantiate ACE_Map_Manager<ACE_Active_Map_Manager_Key, id_expanded_value, ACE_Null_Mutex>
#pragma instantiate ACE_Map_Iterator_Base<ACE_Active_Map_Manager_Key, id_expanded_value, ACE_Null_Mutex>
#pragma instantiate ACE_Map_Iterator<ACE_Active_Map_Manager_Key, id_expanded_value, ACE_Null_Mutex>
#pragma instantiate ACE_Map_Reverse_Iterator<ACE_Active_Map_Manager_Key, id_expanded_value, ACE_Null_Mutex>
#pragma instantiate ACE_Map_Entry<ACE_Active_Map_Manager_Key, id_expanded_value>

// Hash Map Manager related.
#pragma instantiate ACE_Hash_Map_Manager_Ex_Adapter<id, value, id_hash, id_compare_keys, TAO_Incremental_Key_Generator>
#pragma instantiate ACE_Hash_Map_Manager_Ex_Adapter<servant, value, servant_hash, servant_compare_keys, noop_servant_key_generator>
#pragma instantiate ACE_Hash_Map_Manager_Ex_Iterator_Adapter<id_value_type, id, value, id_hash, id_compare_keys>
#pragma instantiate ACE_Hash_Map_Manager_Ex_Iterator_Adapter<servant_value_type, servant, value, servant_hash, servant_compare_keys>
#pragma instantiate ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<id_value_type, id, value, id_hash, id_compare_keys>
#pragma instantiate ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<servant_value_type, servant, value, servant_hash, servant_compare_keys>
#pragma instantiate ACE_Hash_Map_Manager_Ex<id, value, id_hash, id_compare_keys, ACE_Null_Mutex>
#pragma instantiate ACE_Hash_Map_Manager_Ex<servant, value, servant_hash, servant_compare_keys, ACE_Null_Mutex>
#pragma instantiate ACE_Hash_Map_Iterator_Base_Ex<id, value, id_hash, id_compare_keys, ACE_Null_Mutex>
#pragma instantiate ACE_Hash_Map_Iterator_Base_Ex<servant, value, servant_hash, servant_compare_keys, ACE_Null_Mutex>
#pragma instantiate ACE_Hash_Map_Iterator_Ex<id, value, id_hash, id_compare_keys, ACE_Null_Mutex>
#pragma instantiate ACE_Hash_Map_Iterator_Ex<servant, value, servant_hash, servant_compare_keys, ACE_Null_Mutex>
#pragma instantiate ACE_Hash_Map_Reverse_Iterator_Ex<id, value, id_hash, id_compare_keys, ACE_Null_Mutex>
#pragma instantiate ACE_Hash_Map_Reverse_Iterator_Ex<servant, value, servant_hash, servant_compare_keys, ACE_Null_Mutex>
#pragma instantiate ACE_Hash_Map_Entry<id, value>
#pragma instantiate ACE_Hash_Map_Entry<servant, value>
#pragma instantiate ACE_Equal_To<id>
#pragma instantiate ACE_Equal_To<servant>

#if (TAO_HAS_MINIMUM_POA_MAPS == 0)
// Map Manager related.
#pragma instantiate ACE_Map_Manager_Iterator_Adapter<id_value_type, id, value>
#pragma instantiate ACE_Map_Manager_Iterator_Adapter<servant_value_type, servant, value>
#pragma instantiate ACE_Map_Manager_Reverse_Iterator_Adapter<id_value_type, id, value>
#pragma instantiate ACE_Map_Manager_Reverse_Iterator_Adapter<servant_value_type, servant, value>
#pragma instantiate ACE_Map_Manager_Adapter<id, value, TAO_Incremental_Key_Generator>
#pragma instantiate ACE_Map_Manager_Adapter<servant, value, noop_servant_key_generator>
#pragma instantiate ACE_Map_Manager<id, value, ACE_Null_Mutex>
#pragma instantiate ACE_Map_Manager<servant, value, ACE_Null_Mutex>
#pragma instantiate ACE_Map_Iterator_Base<id, value, ACE_Null_Mutex>
#pragma instantiate ACE_Map_Iterator_Base<servant, value, ACE_Null_Mutex>
#pragma instantiate ACE_Map_Iterator<id, value, ACE_Null_Mutex>
#pragma instantiate ACE_Map_Iterator<servant, value, ACE_Null_Mutex>
#pragma instantiate ACE_Map_Reverse_Iterator<id, value, ACE_Null_Mutex>
#pragma instantiate ACE_Map_Reverse_Iterator<servant, value, ACE_Null_Mutex>
#pragma instantiate ACE_Map_Entry<id, value>
#pragma instantiate ACE_Map_Entry<servant, value>
#endif /* TAO_HAS_MINIMUM_POA_MAPS == 0 */

#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
123

active_object_map.cpp - 源码说明

本页面展示了「这是广泛使用的通信开源项目,对于大容量,高并发的通讯要求完全能够胜任,他广泛可用于网络游戏医学图像网关的高qos要求.更详细的内容可阅读相应的材料」中的 active_object_map.cpp 源码文件，采用 C++ 编程语言编写，共 1,161 行代码。您可以在线阅读完整代码内容，也可以返回资源详情页下载完整源码包进行本地学习和开发。

虫虫开发者社区收录了大量与通信框架相关的技术资源，包括源代码、技术文档、电路图等，是电子工程师和嵌入式开发者的专业学习平台。

⌨️ 快捷键说明

复制代码Ctrl + C
搜索代码Ctrl + F
全屏模式F11
增大字号Ctrl + =
减小字号Ctrl + -
显示快捷键?