X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Finstance.hpp;h=73d74a66c43dfe7ca4dd87b048b74df94b8b10b9;hb=879ce2d055d3c4ebdbfa50e26877ee5948b04365;hp=a69b8ea37985ad5724c0c447546fd8d5bc361ebb;hpb=674c7578fa870c3b57e81e765c355ce98434b310;p=awesomized%2Flibmemcached

diff --git a/libmemcached/instance.hpp b/libmemcached/instance.hpp
index a69b8ea3..73d74a66 100644
--- a/libmemcached/instance.hpp
+++ b/libmemcached/instance.hpp
@@ -2,7 +2,7 @@
  * 
  *  Libmemcached library
  *
- *  Copyright (C) 2012 Data Differential, http://datadifferential.com/ 
+ *  Copyright (C) 2012-2013 Data Differential, http://datadifferential.com/ 
  *  All rights reserved.
  *
  *  Redistribution and use in source and binary forms, with or without
@@ -38,25 +38,163 @@
 
 #pragma once
 
-org::libmemcached::Instance* __instance_create_with(memcached_st *memc,
-                                                    org::libmemcached::Instance* self,
-                                                    const memcached_string_t& hostname,
-                                                    const in_port_t port,
-                                                    uint32_t weight, 
-                                                    const memcached_connection_t type);
+#ifndef WIN32
+# ifdef HAVE_NETDB_H
+#  include <netdb.h>
+# endif
+#endif
 
-const char *memcached_instance_name(const org::libmemcached::Instance* self);
+#ifdef NI_MAXHOST
+# define MEMCACHED_NI_MAXHOST NI_MAXHOST
+#else
+# define MEMCACHED_NI_MAXHOST 1025
+#endif
 
-in_port_t memcached_instance_port(const org::libmemcached::Instance* self);
+#ifdef NI_MAXSERV
+# define MEMCACHED_NI_MAXSERV NI_MAXSERV
+#else
+# define MEMCACHED_NI_MAXSERV 32
+#endif
 
-memcached_return_t memcached_instance_push(memcached_st *ptr, const org::libmemcached::Instance*, uint32_t);
+#include "libmemcached/string.hpp"
 
-memcached_server_st *memcached_instance_2_server(org::libmemcached::Instance* source);
+// @todo Complete class transformation
+struct memcached_instance_st {
+  in_port_t port() const
+  {
+    return port_;
+  }
 
-uint32_t memcached_instance_count(const memcached_st* self);
+  void port(in_port_t arg)
+  {
+    port_= arg;
+  }
 
-uint32_t memcached_instance_response_count(const org::libmemcached::Instance* self);
+  void mark_server_as_clean()
+  {
+    server_failure_counter= 0;
+    server_timeout_counter= 0;
+    next_retry= 0;
+  }
 
-uint32_t memcached_instance_set_count(org::libmemcached::Instance *servers, uint32_t count);
+  void disable()
+  {
+  }
 
-void __instance_free(org::libmemcached::Instance *);
+  void enable()
+  {
+  }
+
+  bool valid() const;
+
+  bool is_shutting_down() const;
+
+  void start_close_socket();
+  void close_socket();
+  void reset_socket();
+
+  uint32_t response_count() const
+  {
+    return cursor_active_;
+  }
+
+  struct {
+    bool is_allocated;
+    bool is_initialized;
+    bool is_shutting_down;
+    bool is_dead;
+    bool ready;
+  } options;
+
+  short _events;
+  short _revents;
+
+  short events(void)
+  {
+    return _events;
+  }
+
+  short revents(void)
+  {
+    return _revents;
+  }
+
+  const char* hostname()
+  {
+    return _hostname;
+  }
+
+  void hostname(const memcached_string_t& hostname_)
+  {
+    if (hostname_.size)
+    {
+      memcpy(_hostname, hostname_.c_str, hostname_.size);
+      _hostname[hostname_.size]= 0;
+    }
+    else
+    {
+      memcpy(_hostname, memcached_literal_param("localhost"));
+      _hostname[memcached_literal_param_size("localhost")]= 0;
+    }
+  }
+
+  void events(short);
+  void revents(short);
+
+  uint32_t cursor_active_;
+  in_port_t port_;
+  memcached_socket_t fd;
+  uint32_t io_bytes_sent; /* # bytes sent since last read */
+  uint32_t request_id;
+  uint32_t server_failure_counter;
+  uint64_t server_failure_counter_query_id;
+  uint32_t server_timeout_counter;
+  uint32_t server_timeout_counter_query_id;
+  uint32_t weight;
+  uint32_t version;
+  enum memcached_server_state_t state;
+  struct {
+    uint32_t read;
+    uint32_t write;
+    uint32_t timeouts;
+    size_t _bytes_read;
+  } io_wait_count;
+  uint8_t major_version; // Default definition of UINT8_MAX means that it has not been set.
+  uint8_t micro_version; // ditto, and note that this is the third, not second version bit
+  uint8_t minor_version; // ditto
+  memcached_connection_t type;
+  char *read_ptr;
+  size_t read_buffer_length;
+  size_t read_data_length;
+  size_t write_buffer_offset;
+  struct addrinfo *address_info;
+  struct addrinfo *address_info_next;
+  time_t next_retry;
+  struct memcached_st *root;
+  uint64_t limit_maxbytes;
+  struct memcached_error_t *error_messages;
+  char read_buffer[MEMCACHED_MAX_BUFFER];
+  char write_buffer[MEMCACHED_MAX_BUFFER];
+  char _hostname[MEMCACHED_NI_MAXHOST];
+
+  void clear_addrinfo()
+  {
+    if (address_info)
+    {
+      freeaddrinfo(address_info);
+      address_info= NULL;
+      address_info_next= NULL;
+    }
+  }
+};
+
+memcached_instance_st* __instance_create_with(memcached_st *memc,
+                                              memcached_instance_st* self,
+                                              const memcached_string_t& _hostname,
+                                              const in_port_t port,
+                                              uint32_t weight, 
+                                              const memcached_connection_t type);
+
+memcached_return_t memcached_instance_push(memcached_st *ptr, const memcached_instance_st*, uint32_t);
+
+void __instance_free(memcached_instance_st *);