自学教程：C++ ACE_ALLOCATOR_RETURN函数代码示例

intACE_HTTP_Addr::set (const ACE_TCHAR *host_name,                    const ACE_TCHAR *path,                    const ACE_TCHAR *query,                    u_short port){  if (host_name == 0 || path == 0)    return -1;  this->clear ();  ACE_ALLOCATOR_RETURN (this->hostname_, ACE_OS::strdup (host_name), -1);  this->port_number_ = port;  ACE_ALLOCATOR_RETURN (this->path_, ACE_OS::strdup (path), -1);  if (query != 0)    ACE_ALLOCATOR_RETURN (this->query_, ACE_OS::strdup (query), -1);  else    this->query_ = 0;  size_t size = this->url_size (1);  ACE_TCHAR *buffer;  ACE_ALLOCATOR_RETURN (buffer,                        reinterpret_cast<ACE_TCHAR *> (ACE_OS::malloc (size)),                        -1);  if (this->addr_to_string (buffer, size, 1) == -1)    return -1;  this->set_url (buffer);  return 0;}

intACE_Mailto_Addr::set (const ACE_TCHAR *user,                      const ACE_TCHAR *hostname,                      const ACE_TCHAR *headers){  if (user == 0 || hostname == 0)    return -1;  this->clear ();  ACE_ALLOCATOR_RETURN (this->user_, ACE_OS::strdup (user), -1);  ACE_ALLOCATOR_RETURN (this->hostname_, ACE_OS::strdup (hostname), -1);  if (headers != 0)    ACE_ALLOCATOR_RETURN (this->headers_, ACE_OS::strdup (headers), -1);  else    this->headers_ = 0;  size_t size = this->url_size (1);  ACE_TCHAR *buffer;  ACE_ALLOCATOR_RETURN (buffer,                        ACE_reinterpret_cast(ACE_TCHAR *,                                             ACE_OS::malloc (size)),                        -1);  if (this->addr_to_string (buffer, size, 1) == -1)    return -1;  this->set_url (buffer);  return 0;}

intACE_FTP_Addr::string_to_addr (const ACE_TCHAR *address){  if (address == 0)    return -1;  if (ACE_OS::strncasecmp (ftp, address, ftp_size) != 0)    return -1;  this->clear ();  this->hostname_ = 0;  this->user_ = 0;  this->password_ = 0;  this->path_ = 0;  // Save the original URL....  this->ACE_URL_Addr::string_to_addr (address);  const ACE_TCHAR *string = address;  string += ftp_size;  string += 2; // == strlen ("//");  // Make a copy of the string to manipulate it.  ACE_TCHAR *t;  ACE_ALLOCATOR_RETURN (t, ACE_OS::strdup (string), -1);  ACE_TCHAR *path_start = ACE_OS::strchr (t, '/');  if (path_start != 0)    {      // terminate the host:port substring      path_start[0] = '/0';      path_start++;      ACE_ALLOCATOR_RETURN (this->path_, ACE_OS::strdup (path_start), -1);    }  ACE_TCHAR *host_start = ACE_OS::strchr (t, '@');  if (host_start != 0)    {      host_start[0] = '/0';      host_start++;      ACE_ALLOCATOR_RETURN (this->hostname_,                            ACE_OS::strdup (host_start),                            -1);      ACE_TCHAR *pass_start = ACE_OS::strchr (t, ':');      if (pass_start != 0)        {          pass_start[0] = '/0';          pass_start++;          ACE_ALLOCATOR_RETURN (this->password_,                                ACE_OS::strdup (pass_start),                                -1);        }      this->user_ = t;    }  else    {      this->hostname_ = t;    }  return 0;}

ACE_UINT16 *ACE_NS_WString::ushort_rep (void) const{  ACE_TRACE ("ACE_NS_WString::ushort_rep");  if (this->len_ <= 0)    return 0;  else    {      ACE_UINT16 *t = 0;#if defined (ACE_HAS_ALLOC_HOOKS)      ACE_ALLOCATOR_RETURN (t,                            static_cast<ACE_UINT16*> (ACE_Allocator::instance()->malloc(sizeof(ACE_UINT16) * (this->len_ + 1))),                            0);#else      ACE_NEW_RETURN (t,                      ACE_UINT16[this->len_ + 1],                      0);#endif      for (size_type i = 0; i < this->len_; ++i)        // Note that this cast may lose data if wide chars are        // actually used!        t[i] = (ACE_UINT16)this->rep_[i];      t[this->len_] = 0;      return t;    }}

static intinit_buffer (size_t index){  ACE_INT32 len; if (ACE::recv_n (poll_array[index].fd,                  (void *) &len,                  sizeof (ACE_INT32)) != sizeof (ACE_INT32))    ACE_ERROR_RETURN ((LM_ERROR,                       "(%P|%t) %p/n",                       "recv_n failed"),                      -1);  else    {      len = ntohl (len);      ACE_DEBUG ((LM_DEBUG,                  "(%P|%t) reading messages of size %d from handle %d/n",                  len,                  poll_array[index].fd));      ACE_ALLOCATOR_RETURN (buffer_array[index].buf_,                            ACE_OS::malloc (len),                            -1);      buffer_array[index].len_ = len;    }  return 0;}

template<class T> intACE_Array_Base<T>::max_size (size_t new_size){  if (new_size > this->max_size_)    {      T *tmp = 0;      ACE_ALLOCATOR_RETURN (tmp,                            (T *) this->allocator_->malloc (new_size * sizeof (T)),                            -1);      for (size_t i = 0; i < this->cur_size_; ++i)        new (&tmp[i]) T (this->array_[i]);      // Initialize the new portion of the array that exceeds the      // previously allocated section.      for (size_t j = this->cur_size_; j < new_size; j++)        new (&tmp[j]) T;      ACE_DES_ARRAY_FREE (this->array_,                          this->max_size_,                          this->allocator_->free,                          T);      this->array_ = tmp;      this->max_size_ = new_size;      this->cur_size_ = new_size;    }  return 0;}

template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> intACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::trybind_i (const EXT_ID &ext_id,                                                                                      INT_ID &int_id,                                                                                      ACE_Hash_Map_Entry<EXT_ID, INT_ID> *&entry){  size_t loc;  int result = this->shared_find (ext_id, entry, loc);  if (result == -1)    {      // Not found.      void *ptr;      ACE_ALLOCATOR_RETURN (ptr,                            this->allocator_->malloc (sizeof (ACE_Hash_Map_Entry<EXT_ID, INT_ID>)),                            -1);      entry = new (ptr) ACE_Hash_Map_Entry<EXT_ID, INT_ID> (ext_id,                                                            int_id,                                                            this->table_[loc].next_,                                                            &this->table_[loc]);      this->table_[loc].next_ = entry;      entry->next_->prev_ = entry;      this->cur_size_++;      return 0;    }  else    return 1;}

// utility functionsvoid* createIndex(const std::string& tag                  , PersistenceUpdater::ALLOCATOR& allocator                  , size_t size, bool& exists){  void* index = 0;  // This is the easy case since if we find hash table in the  // memory-mapped file we know it's already initialized.  if (allocator.find(tag.c_str(), index) == 0) {    exists = true;    return index;  } else {    exists = false;    ACE_ALLOCATOR_RETURN(index, allocator.malloc(size), 0);    if (allocator.bind(tag.c_str(), index) == -1) {      allocator.free(index);      index = 0;    }  }  return index;}

intACE_INET_Addr::string_to_addr (const char s[], int address_family){  ACE_TRACE ("ACE_INET_Addr::string_to_addr");  int result;  char *ip_buf = 0;  char *ip_addr = 0;  // Need to make a duplicate since we'll be overwriting the string.  ACE_ALLOCATOR_RETURN (ip_buf,                        ACE_OS::strdup (s),                        -1);  ip_addr = ip_buf;  // We use strrchr because of IPv6 addresses.  char *port_p = ACE_OS::strrchr (ip_addr, ':');#if defined (ACE_HAS_IPV6)  // Check for extended IPv6 format : '[' <ipv6 address> ']' ':' <port>  if (ip_addr[0] == '[')    {      // find closing bracket      char *cp_pos = ACE_OS::strchr (ip_addr, ']');      // check for port separator after closing bracket      // if not found leave it, error will come later      if (cp_pos)        {          *cp_pos = '/0'; // blank out ']'          ++ip_addr; // skip over '['          if (cp_pos[1] == ':')            port_p = cp_pos + 1;          else            port_p = cp_pos; // leads to error on missing port        }    }#endif /* ACE_HAS_IPV6 */  if (port_p == 0) // Assume it's a port number.    {      char *endp = 0;      u_short port =        static_cast<u_short> (ACE_OS::strtol (ip_addr, &endp, 10));      if (*endp == '/0')    // strtol scanned the entire string - all digits        result = this->set (port, ACE_UINT32 (INADDR_ANY));      else // port name        result = this->set (ip_addr, ACE_UINT32 (INADDR_ANY));    }  else    {      *port_p = '/0'; ++port_p; // skip over ':'      char *endp = 0;      u_short port = static_cast<u_short> (ACE_OS::strtol (port_p, &endp, 10));      if (*endp == '/0')    // strtol scanned the entire string - all digits        result = this->set (port, ip_addr, 1, address_family);      else        result = this->set (port_p, ip_addr);    }  ACE_OS::free (ACE_MALLOC_T (ip_buf));  return result;}

intACE_Data_Block::size (size_t length){  ACE_TRACE ("ACE_Data_Block::size");  if (length <= this->max_size_)    this->cur_size_ = length;  else    {      // We need to resize!      char *buf = 0;      ACE_ALLOCATOR_RETURN (buf,                            (char *) this->allocator_strategy_->malloc (length),                            -1);      ACE_OS::memcpy (buf,                      this->base_,                      this->cur_size_);      if (ACE_BIT_DISABLED (this->flags_,                            ACE_Message_Block::DONT_DELETE))        this->allocator_strategy_->free ((void *) this->base_);      else        // We now assume ownership.        ACE_CLR_BITS (this->flags_,                      ACE_Message_Block::DONT_DELETE);      this->max_size_ = length;      this->cur_size_ = length;      this->base_ = buf;    }  return 0;}

template <class SVC_HANDLER> intACE_DLL_Strategy<SVC_HANDLER>::make_svc_handler (SVC_HANDLER *&sh){  ACE_TRACE ("ACE_DLL_Strategy<SVC_HANDLER>::make_svc_handler");  // Open the shared library.  ACE_SHLIB_HANDLE handle = ACE_OS::dlopen (this->dll_name_);  // Extract the factory function.#if defined (ACE_OPENVMS)  SVC_HANDLER *(*factory)(void) =    (SVC_HANDLER *(*)(void)) ACE::ldsymbol (handle,                                            this->factory_function_);#else  SVC_HANDLER *(*factory)(void) =    (SVC_HANDLER *(*)(void)) ACE_OS::dlsym (handle,                                            this->factory_function_);#endif  // Call the factory function to obtain the new SVC_Handler (should  // use RTTI here when it becomes available...)  SVC_HANDLER *svc_handler = 0;  ACE_ALLOCATOR_RETURN (svc_handler, (*factory)(), -1);  if (svc_handler != 0)    {      // Create an ACE_Service_Type containing the SVC_Handler and      // insert into this->svc_rep_;      ACE_Service_Type_Impl *stp = 0;      ACE_NEW_RETURN (stp,                      ACE_Service_Object_Type (svc_handler,                                               this->svc_name_),                      -1);      ACE_Service_Type *srp = 0;      ACE_NEW_RETURN (srp,                      ACE_Service_Type (this->svc_name_,                                        stp,                                        handle,                                        1),                      -1);      if (srp == 0)        {          delete stp;          errno = ENOMEM;          return -1;        }      if (this->svc_rep_->insert (srp) == -1)        return -1;      // @@ Somehow, we need to deal with this->thr_mgr_...    }  sh = svc_handler;  return 0;}

intACE_SPIPE_Addr::set (const ACE_TCHAR *addr,                     gid_t gid,                     uid_t uid){  int len = sizeof (this->SPIPE_addr_.uid_);  len += sizeof (this->SPIPE_addr_.gid_);#if defined (ACE_WIN32)  const ACE_TCHAR *colonp = ACE_OS::strchr (addr, ':');  ACE_TCHAR temp[BUFSIZ];  if (colonp == 0) // Assume it's a local name.    {      ACE_OS::strcpy (temp, ACE_TEXT ( "////.//pipe//"));      ACE_OS::strcat (temp, addr);    }  else    {      if (ACE_OS::strncmp (addr,                           ACE_TEXT ("localhost"),                           ACE_OS::strlen ("localhost")) == 0)        // change "localhost" to "."        ACE_OS::strcpy (temp, ACE_TEXT ("////."));      else        {          ACE_OS::strcpy (temp, ACE_TEXT ("////"));          ACE_TCHAR *t;          // We need to allocate a duplicate so that we can write a          // NUL character into it.          ACE_ALLOCATOR_RETURN (t, ACE_OS::strdup (addr), -1);          t[colonp - addr] = ACE_TEXT ('/0');          ACE_OS::strcat (temp, t);          ACE_OS::free (t);        }      ACE_OS::strcat (temp, ACE_TEXT ("//pipe//"));      ACE_OS::strcat (temp, colonp + 1);    }  len += static_cast<int> (ACE_OS::strlen (temp));  this->ACE_Addr::base_set (AF_SPIPE, len);  ACE_OS::strcpy (this->SPIPE_addr_.rendezvous_, temp);#else  this->ACE_Addr::base_set (AF_SPIPE,                            ACE_OS::strlen (addr) + 1 + len);  ACE_OS::strsncpy (this->SPIPE_addr_.rendezvous_,                    addr,                    sizeof this->SPIPE_addr_.rendezvous_);#endif /* ACE_WIN32 */  this->SPIPE_addr_.gid_ = gid == 0 ? ACE_OS::getgid () : gid;  this->SPIPE_addr_.uid_ = uid == 0 ? ACE_OS::getuid () : uid;  return 0;}

intACEXML_URL_Addr::set (const ACEXML_URL_Addr &addr){  ACE_OS::free (this->path_name_);  ACE_OS::free (this->addr_string_);  if (this->ACE_INET_Addr::set (addr) == -1)    return -1;  else    {      if (addr.path_name_)        ACE_ALLOCATOR_RETURN (this->path_name_,                              ACE_OS::strdup (addr.path_name_),                              -1);      if (addr.addr_string_)        ACE_ALLOCATOR_RETURN (this->addr_string_,                              ACE_OS::strdup (addr.addr_string_),                              -1);      this->addr_string_len_ = addr.addr_string_len_;      return 0;    }}

intACEXML_URL_Addr::string_to_addr (const ACEXML_Char* s,                                 int /*address_family */){  if (s == 0)    return -1;  const ACEXML_Char* http = ACE_TEXT ("http://");  size_t http_len = ACE_OS::strlen (http);  // Check validity of URL  if (ACE_OS::strncmp (http, s, http_len) != 0)    ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("Invalid URL %s/n"), s), -1);  const ACEXML_Char* url = 0;  // Get the host name  for (url = s + http_len; *url != '/0' && *url != ':' && *url != '/'; ++url)    ;  size_t host_len = url - s;  host_len -= http_len;  ACEXML_Char* host_name = 0;  ACE_NEW_RETURN (host_name, ACEXML_Char[host_len + 1], -1);  ACE_OS::strncpy (host_name, s + http_len, host_len);  host_name[host_len] = '/0';  ACE_Auto_Basic_Array_Ptr<ACEXML_Char> cleanup_host_name (host_name);  // Get the port number (if any)  unsigned short port = ACE_DEFAULT_HTTP_PORT;  if (*url == ':')    {      port = (unsigned short) ACE_OS::strtol (++url, 0, 10); // Skip over ':'      while ( *url != '/0' && *url != '/' )        ++url;    }  // Set the addr  int result = this->ACE_INET_Addr::set (port, host_name);  if (result == -1)    return -1;  // Get the path name  const ACEXML_Char* path_name = 0;  if (*url == '/0')    path_name = ACE_TEXT ("/");  else    path_name = url;  ACE_ALLOCATOR_RETURN (this->path_name_, ACE_OS::strdup (path_name), -1);  return result;}

intACE_Log_Record::print (const ACE_TCHAR host_name[],                       u_long verbose_flag,                       FILE *fp){  if ( log_priority_enabled(this->category(), ACE_Log_Priority (this->type_)) )    {      ACE_TCHAR *verbose_msg = 0;#if defined (ACE_HAS_ALLOC_HOOKS)      ACE_ALLOCATOR_RETURN (verbose_msg, static_cast<ACE_TCHAR *>(ACE_Allocator::instance()->malloc(sizeof(ACE_TCHAR) * MAXVERBOSELOGMSGLEN)), -1);#else      ACE_NEW_RETURN (verbose_msg, ACE_TCHAR[MAXVERBOSELOGMSGLEN], -1);#endif /* ACE_HAS_ALLOC_HOOKS */      int result = this->format_msg (host_name, verbose_flag, verbose_msg,                                     MAXVERBOSELOGMSGLEN);      if (result == 0)        {          if (fp != 0)            {              int const verbose_msg_len =                static_cast<int> (ACE_OS::strlen (verbose_msg));#if !defined (ACE_WIN32) && defined (ACE_USES_WCHAR)              int const fwrite_result = ACE_OS::fprintf (fp,                                                         ACE_TEXT ("%ls"),                                                         verbose_msg);#else              int const fwrite_result = ACE_OS::fprintf (fp,                                                         ACE_TEXT ("%s"),                                                         verbose_msg);#endif              // We should have written everything              if (fwrite_result != verbose_msg_len)                result = -1;              else                ACE_OS::fflush (fp);            }        }#if defined (ACE_HAS_ALLOC_HOOKS)      ACE_Allocator::instance()->free(verbose_msg);#else      delete [] verbose_msg;#endif /* ACE_HAS_ALLOC_HOOKS */      return result;    }  else    return 0;}

template <class ACE_CHAR_T> ACE_CHAR_T *ACE_String_Base<ACE_CHAR_T>::rep (void) const{  ACE_TRACE ("ACE_String_Base<ACE_CHAR_T>::rep");  ACE_CHAR_T *new_string;#if defined (ACE_HAS_ALLOC_HOOKS)  ACE_ALLOCATOR_RETURN (new_string, static_cast<ACE_CHAR_T*>(ACE_Allocator::instance()->malloc(sizeof(ACE_CHAR_T) * (this->len_ + 1))), 0);#else  ACE_NEW_RETURN (new_string, ACE_CHAR_T[this->len_ + 1], 0);#endif  ACE_OS::strsncpy (new_string, this->rep_, this->len_+1);  return new_string;}

template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> intACE_Hash_Multi_Map_Manager<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::bind_i (const EXT_ID &ext_id,                                                                                      const INT_ID &int_id,                                                                                      ACE_Hash_Multi_Map_Entry<EXT_ID, INT_ID> *&entry){  size_t loc;  int result = this->shared_find (ext_id, entry, loc);  ACE_Unbounded_Set<INT_ID> int_id_set;  if (result == -1)    {      void *ptr;      // Not found.      ACE_ALLOCATOR_RETURN (ptr,                            this->entry_allocator_->malloc (sizeof (ACE_Hash_Multi_Map_Entry<EXT_ID, INT_ID>)),                            -1);      int_id_set.insert (int_id);      entry = new (ptr) ACE_Hash_Multi_Map_Entry<EXT_ID, INT_ID> (ext_id,                                                                  int_id_set,                                                                  this->table_[loc].next_,                                                                  &this->table_[loc]);      this->table_[loc].next_ = entry;      entry->next_->prev_ = entry;      this->cur_size_++;      return 0;    }  else    {      int_id_set = (*entry).int_id_set_;      if (0 == int_id_set.insert (int_id))        {          this->unbind_i (entry);          return this->bind_i (ext_id, int_id_set);        }      else        return 1;    }}

intACE_DLL_Manager::open (int size){  ACE_TRACE ("ACE_DLL_Manager::open");  ACE_DLL_Handle **temp = 0;#if defined (ACE_HAS_ALLOC_HOOKS)  ACE_ALLOCATOR_RETURN (temp,                        static_cast<ACE_DLL_Handle**> (ACE_Allocator::instance()->malloc(sizeof (ACE_DLL_Handle*) * size)),                        -1);#else  ACE_NEW_RETURN (temp,                  ACE_DLL_Handle *[size],                  -1);#endif /* ACE_HAS_ALLOC_HOOKS */  this->handle_vector_ = temp;  this->total_size_ = size;  return 0;}

intACE_INET_Addr::string_to_addr (const char s[]){  ACE_TRACE ("ACE_INET_Addr::string_to_addr");  int result;  char *ip_addr;  // Need to make a duplicate since we'll be overwriting the string.  ACE_ALLOCATOR_RETURN (ip_addr,                        ACE_OS::strdup (s),                        -1);  // We use strrchr because of IPv6 addresses.  char *port_p = ACE_OS::strrchr (ip_addr, ':');  if (port_p == 0) // Assume it's a port number.    {      char *endp = 0;      u_short port =        static_cast<u_short> (ACE_OS::strtol (ip_addr, &endp, 10));      if (port > 0 && *endp == '/0')        result = this->set (port, ACE_UINT32 (INADDR_ANY));      else // port name        result = this->set (ip_addr, ACE_UINT32 (INADDR_ANY));    }  else    {      *port_p = '/0'; ++port_p; // skip over ':'      char *endp = 0;      u_short port = static_cast<u_short> (ACE_OS::strtol (port_p, &endp, 10));      if (port > 0 && *endp == '/0')        result = this->set (port, ip_addr);      else        result = this->set (port_p, ip_addr);    }  ACE_OS::free (ACE_MALLOC_T (ip_addr));  return result;}

intHandler_Factory::create_handler (  ACE_SSL_SOCK_Acceptor &acceptor,  Handler * (*handler_factory) (ACE_SSL_SOCK_Stream* ),  const char *handler_type){  ACE_SSL_SOCK_Stream* new_stream;  ACE_NEW_RETURN (new_stream, ACE_SSL_SOCK_Stream, -1);  if (acceptor.accept (*new_stream) == -1)    ACE_ERROR_RETURN ((LM_ERROR,                       ACE_TEXT ("%p/n"),                       ACE_TEXT ("accept")),                       -1);  Handler *handler;  ACE_ALLOCATOR_RETURN (handler,                        (*handler_factory) (new_stream),                        -1);  ACE_DEBUG ((LM_DEBUG,              ACE_TEXT ("(%P|%t) spawning %s handler/n"),              handler_type));  if (handler->open () == -1)    return -1;#if defined (ACE_MT_SAFE)  // Spawn a new thread and run the new connection in that thread of  // control using the <server> function as the entry point.  return handler->activate ();#else  handler->svc ();  handler->close (0);  return 0;#endif /* ACE_HAS_THREADS */}