libmemcached: headers diff between 0.53 and 1.0.2 versions

	constants.h	constants.h

	skipping to change at line 123	skipping to change at line 123

	#ifndef __cplusplus	#ifndef __cplusplus
	typedef enum memcached_behavior_t memcached_behavior_t;	typedef enum memcached_behavior_t memcached_behavior_t;
	#endif	#endif

	enum memcached_callback_t {	enum memcached_callback_t {
	MEMCACHED_CALLBACK_PREFIX_KEY = 0,	MEMCACHED_CALLBACK_PREFIX_KEY = 0,
	MEMCACHED_CALLBACK_USER_DATA = 1,	MEMCACHED_CALLBACK_USER_DATA = 1,
	MEMCACHED_CALLBACK_CLEANUP_FUNCTION = 2,	MEMCACHED_CALLBACK_CLEANUP_FUNCTION = 2,
	MEMCACHED_CALLBACK_CLONE_FUNCTION = 3,	MEMCACHED_CALLBACK_CLONE_FUNCTION = 3,

	#ifdef MEMCACHED_ENABLE_DEPRECATED
	MEMCACHED_CALLBACK_MALLOC_FUNCTION = 4,
	MEMCACHED_CALLBACK_REALLOC_FUNCTION = 5,
	MEMCACHED_CALLBACK_FREE_FUNCTION = 6,
	#endif
	MEMCACHED_CALLBACK_GET_FAILURE = 7,	MEMCACHED_CALLBACK_GET_FAILURE = 7,
	MEMCACHED_CALLBACK_DELETE_TRIGGER = 8,	MEMCACHED_CALLBACK_DELETE_TRIGGER = 8,
	MEMCACHED_CALLBACK_MAX,	MEMCACHED_CALLBACK_MAX,
	MEMCACHED_CALLBACK_NAMESPACE= MEMCACHED_CALLBACK_PREFIX_KEY	MEMCACHED_CALLBACK_NAMESPACE= MEMCACHED_CALLBACK_PREFIX_KEY
	};	};

	#ifndef __cplusplus	#ifndef __cplusplus
	typedef enum memcached_callback_t memcached_callback_t;	typedef enum memcached_callback_t memcached_callback_t;
	#endif	#endif


End of changes. 1 change blocks.
	5 lines changed or deleted	0 lines changed or added

	function.h	function.h
	/* HashKit	/* HashKit
	* Copyright (C) 2010 Brian Aker	* Copyright (C) 2010 Brian Aker
	* All rights reserved.	* All rights reserved.
	*	*
	* Use and distribution licensed under the BSD license. See	* Use and distribution licensed under the BSD license. See
	* the COPYING file in the parent directory for full text.	* the COPYING file in the parent directory for full text.
	*/	*/


	#ifndef HASHKIT_FUNCTION_H	#pragma once
	#define HASHKIT_FUNCTION_H

	#ifdef __cplusplus	#ifdef __cplusplus
	extern "C" {	extern "C" {
	#endif	#endif

	/**	/**
	This sets/gets the default function we will be using.	This sets/gets the default function we will be using.
	*/	*/
	HASHKIT_API	HASHKIT_API
	hashkit_return_t hashkit_set_function(hashkit_st *hash, hashkit_hash_algori thm_t hash_algorithm);	hashkit_return_t hashkit_set_function(hashkit_st *hash, hashkit_hash_algori thm_t hash_algorithm);

	skipping to change at line 43	skipping to change at line 42

	HASHKIT_API	HASHKIT_API
	hashkit_return_t hashkit_set_custom_distribution_function(hashkit_st self, hashkit_hash_fn function, void context);	hashkit_return_t hashkit_set_custom_distribution_function(hashkit_st self, hashkit_hash_fn function, void context);

	HASHKIT_API	HASHKIT_API
	hashkit_hash_algorithm_t hashkit_get_distribution_function(const hashkit_st *self);	hashkit_hash_algorithm_t hashkit_get_distribution_function(const hashkit_st *self);

	#ifdef __cplusplus	#ifdef __cplusplus
	}	}
	#endif	#endif


	#endif /* HASHKIT_FUNCTION_H */

End of changes. 2 change blocks.
	2 lines changed or deleted	1 lines changed or added

	hashkit.h	hashkit.h
	/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:	/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
	*	*
	* HashKit library	* HashKit library
	*	*
	* Copyright (C) 2011 Data Differential, http://datadifferential.com/	* Copyright (C) 2011 Data Differential, http://datadifferential.com/

	* Copyright (C) 2009-2010 Brian Aker All rights reserved.
	*	*
	* Redistribution and use in source and binary forms, with or without	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are	* modification, are permitted provided that the following conditions are
	* met:	* met:
	*	*
	* * Redistributions of source code must retain the above copyright	* * Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.	* notice, this list of conditions and the following disclaimer.
	*	*
	* * Redistributions in binary form must reproduce the above	* * Redistributions in binary form must reproduce the above
	* copyright notice, this list of conditions and the following disclaimer	* copyright notice, this list of conditions and the following disclaimer

	skipping to change at line 40	skipping to change at line 39
	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*	*
	*/	*/

	#pragma once	#pragma once


	#if !defined(__cplusplus)	#include <libhashkit-1.0/hashkit.h>
	# include <stdbool.h>
	#endif
	#include <inttypes.h>
	#include <sys/types.h>

	#include <libhashkit/visibility.h>
	#include <libhashkit/configure.h>
	#include <libhashkit/types.h>
	#include <libhashkit/has.h>
	#include <libhashkit/algorithm.h>
	#include <libhashkit/behavior.h>
	#include <libhashkit/digest.h>
	#include <libhashkit/function.h>
	#include <libhashkit/str_algorithm.h>
	#include <libhashkit/strerror.h>

	struct hashkit_st
	{
	struct hashkit_function_st {
	hashkit_hash_fn function;
	void *context;
	} base_hash, distribution_hash;

	struct {
	bool is_base_same_distributed:1;
	} flags;

	struct {
	bool is_allocated:1;
	} options;
	};

	#ifdef __cplusplus
	extern "C" {
	#endif

	HASHKIT_API
	hashkit_st hashkit_create(hashkit_st hash);

	HASHKIT_API
	hashkit_st hashkit_clone(hashkit_st destination, const hashkit_st *ptr);

	HASHKIT_API
	bool hashkit_compare(const hashkit_st first, const hashkit_st second);

	HASHKIT_API
	void hashkit_free(hashkit_st *hash);

	#define hashkit_is_allocated(__object) ((__object)->options.is_allocated)
	#define hashkit_is_initialized(__object) ((__object)->options.is_initialize
	d)

	#ifdef __cplusplus
	} // extern "C"
	#endif

End of changes. 2 change blocks.
	1 lines changed or deleted	0 lines changed or added

	hashkit.hpp	hashkit.hpp

	skipping to change at line 40	skipping to change at line 40
	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*	*
	*/	*/

	#pragma once	#pragma once


	#include <libhashkit/hashkit.h>	#include <libhashkit-1.0/hashkit.h>
	#include <string>	#include <string>

	class Hashkit {	class Hashkit {

	public:	public:

	Hashkit()	Hashkit()
	{	{
	hashkit_create(&self);	hashkit_create(&self);
	}	}

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	memcached.h	memcached.h
	/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:	/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
	*	*
	* Libmemcached library	* Libmemcached library
	*	*
	* Copyright (C) 2011 Data Differential, http://datadifferential.com/	* Copyright (C) 2011 Data Differential, http://datadifferential.com/

	* Copyright (C) 2006-2009 Brian Aker All rights reserved.
	*	*
	* Redistribution and use in source and binary forms, with or without	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are	* modification, are permitted provided that the following conditions are
	* met:	* met:
	*	*
	* * Redistributions of source code must retain the above copyright	* * Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.	* notice, this list of conditions and the following disclaimer.
	*	*
	* * Redistributions in binary form must reproduce the above	* * Redistributions in binary form must reproduce the above
	* copyright notice, this list of conditions and the following disclaimer	* copyright notice, this list of conditions and the following disclaimer

	skipping to change at line 40	skipping to change at line 39
	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*	*
	*/	*/

	#pragma once	#pragma once


	#include <inttypes.h>	#include <libmemcached-1.0/memcached.h>
	#include <stdlib.h>
	#include <sys/types.h>

	#if !defined(__cplusplus)
	# include <stdbool.h>
	#endif

	#include <libmemcached/visibility.h>
	#include <libmemcached/configure.h>
	#include <libmemcached/platform.h>
	#include <libmemcached/constants.h>
	#include <libmemcached/return.h>
	#include <libmemcached/types.h>
	#include <libmemcached/string.h>
	#include <libmemcached/array.h>
	#include <libmemcached/error.h>
	#include <libmemcached/stats.h>
	#include <libhashkit/hashkit.h>

	// Everything above this line must be in the order specified.
	#include <libmemcached/allocators.h>
	#include <libmemcached/analyze.h>
	#include <libmemcached/auto.h>
	#include <libmemcached/behavior.h>
	#include <libmemcached/callback.h>
	#include <libmemcached/delete.h>
	#include <libmemcached/dump.h>
	#include <libmemcached/exist.h>
	#include <libmemcached/fetch.h>
	#include <libmemcached/flush.h>
	#include <libmemcached/flush_buffers.h>
	#include <libmemcached/get.h>
	#include <libmemcached/hash.h>
	#include <libmemcached/namespace.h>
	#include <libmemcached/options.h>
	#include <libmemcached/parse.h>
	#include <libmemcached/quit.h>
	#include <libmemcached/result.h>
	#include <libmemcached/server.h>
	#include <libmemcached/server_list.h>
	#include <libmemcached/storage.h>
	#include <libmemcached/strerror.h>
	#include <libmemcached/verbosity.h>
	#include <libmemcached/version.h>
	#include <libmemcached/sasl.h>

	struct memcached_st {
	/**
	@note these are static and should not change without a call to behavior
	.
	*/
	struct {
	bool is_purging:1;
	bool is_processing_input:1;
	bool is_time_for_rebuild:1;
	} state;

	struct {
	// Everything below here is pretty static.
	bool auto_eject_hosts:1;
	bool binary_protocol:1;
	bool buffer_requests:1;
	bool hash_with_namespace:1;
	bool no_block:1; // Don't block
	bool no_reply:1;
	bool randomize_replica_read:1;
	bool support_cas:1;
	bool tcp_nodelay:1;
	bool use_sort_hosts:1;
	bool use_udp:1;
	bool verify_key:1;
	bool tcp_keepalive:1;
	} flags;

	memcached_server_distribution_t distribution;
	hashkit_st hashkit;
	struct {
	unsigned int version;
	} server_info;
	uint32_t number_of_hosts;
	memcached_server_st *servers;
	memcached_server_st *last_disconnected_server;
	int32_t snd_timeout;
	int32_t rcv_timeout;
	uint32_t server_failure_limit;
	uint32_t io_msg_watermark;
	uint32_t io_bytes_watermark;
	uint32_t io_key_prefetch;
	uint32_t tcp_keepidle;
	int32_t poll_timeout;
	int32_t connect_timeout; // How long we will wait on connect() before we
	will timeout
	int32_t retry_timeout;
	int send_size;
	int recv_size;
	void *user_data;
	uint64_t query_id;
	uint32_t number_of_replicas;
	memcached_result_st result;

	struct {
	bool weighted;
	uint32_t continuum_count; // Ketama
	uint32_t continuum_points_counter; // Ketama
	time_t next_distribution_rebuild; // Ketama
	memcached_continuum_item_st *continuum; // Ketama
	} ketama;

	struct memcached_virtual_bucket_t *virtual_bucket;

	struct memcached_allocator_t allocators;

	memcached_clone_fn on_clone;
	memcached_cleanup_fn on_cleanup;
	memcached_trigger_key_fn get_key_failure;
	memcached_trigger_delete_key_fn delete_trigger;
	memcached_callback_st *callbacks;
	struct memcached_sasl_st sasl;
	struct memcached_error_t *error_messages;
	struct memcached_array_st *_namespace;
	struct {
	uint32_t initial_pool_size;
	uint32_t max_pool_size;
	int32_t version; // This is used by pool and others to determine if the
	memcached_st is out of date.
	struct memcached_array_st *filename;
	} configure;
	struct {
	bool is_allocated:1;
	} options;

	};

	#ifdef __cplusplus
	extern "C" {
	#endif

	LIBMEMCACHED_API
	void memcached_servers_reset(memcached_st *ptr);

	LIBMEMCACHED_API
	memcached_st memcached_create(memcached_st ptr);

	LIBMEMCACHED_API
	memcached_st memcached(const char string, size_t string_length);

	LIBMEMCACHED_API
	void memcached_free(memcached_st *ptr);

	LIBMEMCACHED_API
	memcached_return_t memcached_reset(memcached_st *ptr);

	LIBMEMCACHED_API
	void memcached_reset_last_disconnected_server(memcached_st *ptr);

	LIBMEMCACHED_API
	memcached_st memcached_clone(memcached_st clone, const memcached_st *ptr)
	;

	LIBMEMCACHED_API
	void memcached_get_user_data(const memcached_st ptr);

	LIBMEMCACHED_API
	void memcached_set_user_data(memcached_st ptr, void *data);

	LIBMEMCACHED_API
	memcached_return_t memcached_push(memcached_st *destination, const memcache
	d_st *source);

	LIBMEMCACHED_API
	memcached_server_instance_st memcached_server_instance_by_position(const me
	mcached_st *ptr, uint32_t server_key);

	LIBMEMCACHED_API
	uint32_t memcached_server_count(const memcached_st *);

	LIBMEMCACHED_API
	uint64_t memcached_query_id(const memcached_st *);

	#ifdef __cplusplus
	} // extern "C"
	#endif

End of changes. 2 change blocks.
	1 lines changed or deleted	0 lines changed or added

	memcached.hpp	memcached.hpp

	/*	/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
	* Summary: C++ interface for memcached server
	*	*

	* Copy: See Copyright for the status of this software.	* Libmemcached library
		*
		* Copyright (C) 2011 Data Differential, http://datadifferential.com/
		*
		* Redistribution and use in source and binary forms, with or without
		* modification, are permitted provided that the following conditions are
		* met:
		*
		* * Redistributions of source code must retain the above copyright
		* notice, this list of conditions and the following disclaimer.
		*
		* * Redistributions in binary form must reproduce the above
		* copyright notice, this list of conditions and the following disclaimer
		* in the documentation and/or other materials provided with the
		* distribution.
		*
		* * The names of its contributors may not be used to endorse or
		* promote products derived from this software without specific prior
		* written permission.
		*
		* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
		* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
		* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
		* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
		* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
		* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
		* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
		* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
		* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
		* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
		* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*	*

	* Authors: Padraig O'Sullivan <osullivan.padraig@gmail.com>
	* Patrick Galbraith <patg@patg.net>
	*/

	/**
	* @file memcached.hpp
	* @brief Libmemcached C++ interface
	*/	*/

	#pragma once	#pragma once


	#include <libmemcached/memcached.h>	#include <libmemcached-1.0/memcached.hpp>
	#include <libmemcached/exception.hpp>

	#include <string.h>

	#include <sstream>
	#include <string>
	#include <vector>
	#include <map>

	namespace memcache
	{

	/**
	* This is the core memcached library (if later, other objects
	* are needed, they will be created from this class).
	*/
	class Memcache
	{
	public:

	Memcache()
	{
	memc= memcached("", 0);
	}

	Memcache(const std::string &config)
	{
	memc= memcached(config.c_str(), config.size());
	}

	Memcache(const std::string &hostname, in_port_t port)
	{
	memc= memcached("", 0);
	if (memc)
	memcached_server_add(memc, hostname.c_str(), port);
	}

	Memcache(memcached_st *clone)
	{
	memc= memcached_clone(NULL, clone);
	}

	Memcache(const Memcache &rhs)
	{
	memc= memcached_clone(NULL, rhs.getImpl());
	}

	Memcache &operator=(const Memcache &rhs)
	{
	if (this != &rhs)
	{
	memcached_free(memc);
	memc= memcached_clone(NULL, rhs.getImpl());
	}

	return *this;
	}

	~Memcache()
	{
	memcached_free(memc);
	}

	/**
	* Get the internal memcached_st *
	*/
	const memcached_st *getImpl() const
	{
	return memc;
	}

	/**
	* Return an error string for the given return structure.
	*
	* @param[in] rc a memcached_return_t structure
	* @return error string corresponding to given return code in the library
	.
	*/
	const std::string getError(memcached_return_t rc) const
	{
	/* first parameter to strerror is unused */
	return memcached_strerror(NULL, rc);
	}

	bool error(std::string& error_message) const
	{
	if (memcached_failed(memcached_last_error(memc)))
	{
	error_message+= memcached_last_error_message(memc);
	return true;
	}

	return false;
	}

	bool error() const
	{
	if (memcached_failed(memcached_last_error(memc)))
	{
	return true;
	}

	return false;
	}

	bool error(memcached_return_t& arg) const
	{
	arg= memcached_last_error(memc);
	return memcached_failed(arg);
	}

	bool setBehavior(memcached_behavior_t flag, uint64_t data)
	{
	return (memcached_success(memcached_behavior_set(memc, flag, data)));
	}

	uint64_t getBehavior(memcached_behavior_t flag)
	{
	return memcached_behavior_get(memc, flag);
	}

	/**
	* Configure the memcache object
	*
	* @param[in] in_config configuration
	* @return true on success; false otherwise
	*/
	bool configure(const std::string &configuration)
	{
	memcached_st *new_memc= memcached(configuration.c_str(), configuration.
	size());

	if (new_memc)
	{
	memcached_free(memc);
	memc= new_memc;

	return true;
	}

	return false;
	}

	/**
	* Add a server to the list of memcached servers to use.
	*
	* @param[in] server_name name of the server to add
	* @param[in] port port number of server to add
	* @return true on success; false otherwise
	*/
	bool addServer(const std::string &server_name, in_port_t port)
	{
	return memcached_success(memcached_server_add(memc, server_name.c_str()
	, port));
	}

	/**
	* Remove a server from the list of memcached servers to use.
	*
	* @param[in] server_name name of the server to remove
	* @param[in] port port number of server to remove
	* @return true on success; false otherwise
	*/
	bool removeServer(const std::string &server_name, in_port_t port)
	{
	std::string tmp_str;
	std::ostringstream strstm;
	tmp_str.append(",");
	tmp_str.append(server_name);
	tmp_str.append(":");
	strstm << port;
	tmp_str.append(strstm.str());

	//memcached_return_t rc= memcached_server_remove(server);

	return false;
	}

	/**
	* Fetches an individual value from the server. mget() must always
	* be called before using this method.
	*
	* @param[in] key key of object to fetch
	* @param[out] ret_val store returned object in this vector
	* @return a memcached return structure
	*/
	memcached_return_t fetch(std::string &key,
	std::vector<char> &ret_val,
	uint32_t &flags,
	uint64_t &cas_value)
	{
	memcached_return_t rc;

	memcached_result_st *result;
	if ((result= memcached_fetch_result(memc, NULL, &rc)))
	{
	// Key
	key.assign(memcached_result_key_value(result), memcached_result_key_l
	ength(result));

	// Actual value, null terminated
	ret_val.reserve(memcached_result_length(result) +1);
	ret_val.assign(memcached_result_value(result),
	memcached_result_value(result) +memcached_result_lengt
	h(result));

	// Misc
	flags= memcached_result_flags(result);
	cas_value= memcached_result_cas(result);
	}
	memcached_result_free(result);

	return rc;
	}

	memcached_return_t fetch(std::string &key,
	std::vector<char> &ret_val)
	{
	uint32_t flags= 0;
	uint64_t cas_value= 0;

	return fetch(key, ret_val, flags, cas_value);
	}

	/**
	* Fetches an individual value from the server.
	*
	* @param[in] key key of object whose value to get
	* @param[out] ret_val object that is retrieved is stored in
	* this vector
	* @return true on success; false otherwise
	*/
	bool get(const std::string &key, std::vector<char> &ret_val)
	{
	uint32_t flags= 0;
	memcached_return_t rc;
	size_t value_length= 0;

	char *value= memcached_get(memc, key.c_str(), key.length(),
	&value_length, &flags, &rc);
	if (value != NULL && ret_val.empty())
	{
	ret_val.reserve(value_length);
	ret_val.assign(value, value + value_length);
	free(value);
	return true;
	}

	return false;
	}

	/**
	* Fetches an individual from a server which is specified by
	* the master_key parameter that is used for determining which
	* server an object was stored in if key partitioning was
	* used for storage.
	*
	* @param[in] master_key key that specifies server object is stored on
	* @param[in] key key of object whose value to get
	* @param[out] ret_val object that is retrieved is stored in
	* this vector
	* @return true on success; false otherwise
	*/
	bool getByKey(const std::string &master_key,
	const std::string &key,
	std::vector<char> &ret_val)
	{
	uint32_t flags= 0;
	memcached_return_t rc;
	size_t value_length= 0;

	char *value= memcached_get_by_key(memc,
	master_key.c_str(), master_key.length
	(),
	key.c_str(), key.length(),
	&value_length, &flags, &rc);
	if (value)
	{
	ret_val.reserve(value_length);
	ret_val.assign(value, value + value_length);
	free(value);
	return true;
	}
	return false;
	}

	/**
	* Selects multiple keys at once. This method always
	* works asynchronously.
	*
	* @param[in] keys vector of keys to select
	* @return true if all keys are found
	*/
	bool mget(std::vector<std::string> &keys)
	{
	std::vector<const char *> real_keys;
	std::vector<size_t> key_len;
	/*
	* Construct an array which will contain the length
	* of each of the strings in the input vector. Also, to
	* interface with the memcached C API, we need to convert
	* the vector of std::string's to a vector of char *.
	*/
	real_keys.reserve(keys.size());
	key_len.reserve(keys.size());

	std::vector<std::string>::iterator it= keys.begin();

	while (it != keys.end())
	{
	real_keys.push_back(const_cast<char >((it).c_str()));
	key_len.push_back((*it).length());
	++it;
	}

	/*
	* If the std::vector of keys is empty then we cannot
	* call memcached_mget as we will get undefined behavior.
	*/
	if (not real_keys.empty())
	{
	return memcached_success(memcached_mget(memc, &real_keys[0], &key_len
	[0], real_keys.size()));
	}

	return false;
	}

	/**
	* Writes an object to the server. If the object already exists, it will
	* overwrite the existing object. This method always returns true
	* when using non-blocking mode unless a network error occurs.
	*
	* @param[in] key key of object to write to server
	* @param[in] value value of object to write to server
	* @param[in] expiration time to keep the object stored in the server for
	* @param[in] flags flags to store with the object
	* @return true on succcess; false otherwise
	*/
	bool set(const std::string &key,
	const std::vector<char> &value,
	time_t expiration,
	uint32_t flags)
	{
	memcached_return_t rc= memcached_set(memc,
	key.c_str(), key.length(),
	&value[0], value.size(),
	expiration, flags);
	return memcached_success(rc);
	}

	/**
	* Writes an object to a server specified by the master_key parameter.
	* If the object already exists, it will overwrite the existing object.
	*
	* @param[in] master_key key that specifies server to write to
	* @param[in] key key of object to write to server
	* @param[in] value value of object to write to server
	* @param[in] expiration time to keep the object stored in the server for
	* @param[in] flags flags to store with the object
	* @return true on succcess; false otherwise
	*/
	bool setByKey(const std::string &master_key,
	const std::string &key,
	const std::vector<char> &value,
	time_t expiration,
	uint32_t flags)
	{
	return memcached_success(memcached_set_by_key(memc, master_key.c_str(),
	master_key.length(),
	key.c_str(), key.length()
	,
	&value[0], value.size(),
	expiration,
	flags));
	}

	/**
	* Writes a list of objects to the server. Objects are specified by
	* 2 vectors - 1 vector of keys and 1 vector of values.
	*
	* @param[in] keys vector of keys of objects to write to server
	* @param[in] values vector of values of objects to write to server
	* @param[in] expiration time to keep the objects stored in server for
	* @param[in] flags flags to store with the objects
	* @return true on success; false otherwise
	*/
	bool setAll(std::vector<std::string> &keys,
	std::vector< std::vector<char> *> &values,
	time_t expiration,
	uint32_t flags)
	{
	bool retval= true;
	std::vector<std::string>::iterator key_it= keys.begin();
	std::vector< std::vector<char> *>::iterator val_it= values.begin();
	while (key_it != keys.end())
	{
	retval= set((key_it), (*val_it), expiration, flags);
	if (retval == false)
	{
	return retval;
	}
	++key_it;
	++val_it;
	}
	return retval;
	}

	/**
	* Writes a list of objects to the server. Objects are specified by
	* a map of keys to values.
	*
	* @param[in] key_value_map map of keys and values to store in server
	* @param[in] expiration time to keep the objects stored in server for
	* @param[in] flags flags to store with the objects
	* @return true on success; false otherwise
	*/
	bool setAll(std::map<const std::string, std::vector<char> > &key_value_ma
	p,
	time_t expiration,
	uint32_t flags)
	{
	bool retval= true;
	std::map<const std::string, std::vector<char> >::iterator it= key_value
	_map.begin();

	while (it != key_value_map.end())
	{
	retval= set(it->first, it->second, expiration, flags);
	if (retval == false)
	{
	// We should tell the user what the key that failed was
	return false;
	}
	++it;
	}
	return true;
	}

	/**
	* Increment the value of the object associated with the specified
	* key by the offset given. The resulting value is saved in the value
	* parameter.
	*
	* @param[in] key key of object in server whose value to increment
	* @param[in] offset amount to increment object's value by
	* @param[out] value store the result of the increment here
	* @return true on success; false otherwise
	*/
	bool increment(const std::string &key, uint32_t offset, uint64_t *value)
	{
	return memcached_success(memcached_increment(memc, key.c_str(), key.len
	gth(), offset, value));
	}

	/**
	* Decrement the value of the object associated with the specified
	* key by the offset given. The resulting value is saved in the value
	* parameter.
	*
	* @param[in] key key of object in server whose value to decrement
	* @param[in] offset amount to increment object's value by
	* @param[out] value store the result of the decrement here
	* @return true on success; false otherwise
	*/
	bool decrement(const std::string &key, uint32_t offset, uint64_t *value)
	{
	return memcached_success(memcached_decrement(memc, key.c_str(),
	key.length(),
	offset, value));
	}

	/**
	* Add an object with the specified key and value to the server. This
	* function returns false if the object already exists on the server.
	*
	* @param[in] key key of object to add
	* @param[in] value of object to add
	* @return true on success; false otherwise
	*/
	bool add(const std::string &key, const std::vector<char> &value)
	{
	return memcached_success(memcached_add(memc, key.c_str(), key.length(),
	&value[0], value.size(), 0, 0));
	}

	/**
	* Add an object with the specified key and value to the server. This
	* function returns false if the object already exists on the server. The
	* server to add the object to is specified by the master_key parameter.
	*
	* @param[in[ master_key key of server to add object to
	* @param[in] key key of object to add
	* @param[in] value of object to add
	* @return true on success; false otherwise
	*/
	bool addByKey(const std::string &master_key,
	const std::string &key,
	const std::vector<char> &value)
	{
	return memcached_success(memcached_add_by_key(memc,
	master_key.c_str(),
	master_key.length(),
	key.c_str(),
	key.length(),
	&value[0],
	value.size(),
	0, 0));
	}

	/**
	* Replaces an object on the server. This method only succeeds
	* if the object is already present on the server.
	*
	* @param[in] key key of object to replace
	* @param[in[ value value to replace object with
	* @return true on success; false otherwise
	*/
	bool replace(const std::string &key, const std::vector<char> &value)
	{
	return memcached_success(memcached_replace(memc, key.c_str(), key.lengt
	h(),
	&value[0], value.size(),
	0, 0));
	}

	/**
	* Replaces an object on the server. This method only succeeds
	* if the object is already present on the server. The server
	* to replace the object on is specified by the master_key param.
	*
	* @param[in] master_key key of server to replace object on
	* @param[in] key key of object to replace
	* @param[in[ value value to replace object with
	* @return true on success; false otherwise
	*/
	bool replaceByKey(const std::string &master_key,
	const std::string &key,
	const std::vector<char> &value)
	{
	return memcached_success(memcached_replace_by_key(memc,
	master_key.c_str(),
	master_key.length(),
	key.c_str(),
	key.length(),
	&value[0],
	value.size(),
	0, 0));
	}

	/**
	* Places a segment of data before the last piece of data stored.
	*
	* @param[in] key key of object whose value we will prepend data to
	* @param[in] value data to prepend to object's value
	* @return true on success; false otherwise
	*/
	bool prepend(const std::string &key, const std::vector<char> &value)
	{
	return memcached_success(memcached_prepend(memc, key.c_str(), key.lengt
	h(),
	&value[0], value.size(), 0,
	0));
	}

	/**
	* Places a segment of data before the last piece of data stored. The
	* server on which the object where we will be prepending data is stored
	* on is specified by the master_key parameter.
	*
	* @param[in] master_key key of server where object is stored
	* @param[in] key key of object whose value we will prepend data to
	* @param[in] value data to prepend to object's value
	* @return true on success; false otherwise
	*/
	bool prependByKey(const std::string &master_key,
	const std::string &key,
	const std::vector<char> &value)
	{
	return memcached_success(memcached_prepend_by_key(memc,
	master_key.c_str(),
	master_key.length(),
	key.c_str(),
	key.length(),
	&value[0],
	value.size(),
	0,
	0));
	}

	/**
	* Places a segment of data at the end of the last piece of data stored.
	*
	* @param[in] key key of object whose value we will append data to
	* @param[in] value data to append to object's value
	* @return true on success; false otherwise
	*/
	bool append(const std::string &key, const std::vector<char> &value)
	{
	return memcached_success(memcached_append(memc,
	key.c_str(),
	key.length(),
	&value[0],
	value.size(),
	0, 0));
	}

	/**
	* Places a segment of data at the end of the last piece of data stored.
	The
	* server on which the object where we will be appending data is stored
	* on is specified by the master_key parameter.
	*
	* @param[in] master_key key of server where object is stored
	* @param[in] key key of object whose value we will append data to
	* @param[in] value data to append to object's value
	* @return true on success; false otherwise
	*/
	bool appendByKey(const std::string &master_key,
	const std::string &key,
	const std::vector<char> &value)
	{
	return memcached_success(memcached_append_by_key(memc,
	master_key.c_str(),
	master_key.length(),
	key.c_str(),
	key.length(),
	&value[0],
	value.size(),
	0, 0));
	}

	/**
	* Overwrite data in the server as long as the cas_arg value
	* is still the same in the server.
	*
	* @param[in] key key of object in server
	* @param[in] value value to store for object in server
	* @param[in] cas_arg "cas" value
	*/
	bool cas(const std::string &key,
	const std::vector<char> &value,
	uint64_t cas_arg)
	{
	return memcached_success(memcached_cas(memc, key.c_str(), key.length(),
	&value[0], value.size(),
	0, 0, cas_arg));
	}

	/**
	* Overwrite data in the server as long as the cas_arg value
	* is still the same in the server. The server to use is
	* specified by the master_key parameter.
	*
	* @param[in] master_key specifies server to operate on
	* @param[in] key key of object in server
	* @param[in] value value to store for object in server
	* @param[in] cas_arg "cas" value
	*/
	bool casByKey(const std::string &master_key,
	const std::string &key,
	const std::vector<char> &value,
	uint64_t cas_arg)
	{
	return memcached_success(memcached_cas_by_key(memc,
	master_key.c_str(),
	master_key.length(),
	key.c_str(),
	key.length(),
	&value[0],
	value.size(),
	0, 0, cas_arg));
	}

	/**
	* Delete an object from the server specified by the key given.
	*
	* @param[in] key key of object to delete
	* @return true on success; false otherwise
	*/
	bool remove(const std::string &key)
	{
	return memcached_success(memcached_delete(memc, key.c_str(), key.length
	(), 0));
	}

	/**
	* Delete an object from the server specified by the key given.
	*
	* @param[in] key key of object to delete
	* @param[in] expiration time to delete the object after
	* @return true on success; false otherwise
	*/
	bool remove(const std::string &key, time_t expiration)
	{
	return memcached_success(memcached_delete(memc,
	key.c_str(),
	key.length(),
	expiration));
	}

	/**
	* Delete an object from the server specified by the key given.
	*
	* @param[in] master_key specifies server to remove object from
	* @param[in] key key of object to delete
	* @return true on success; false otherwise
	*/
	bool removeByKey(const std::string &master_key,
	const std::string &key)
	{
	return memcached_success(memcached_delete_by_key(memc,
	master_key.c_str(),
	master_key.length(),
	key.c_str(),
	key.length(),
	0));
	}

	/**
	* Delete an object from the server specified by the key given.
	*
	* @param[in] master_key specifies server to remove object from
	* @param[in] key key of object to delete
	* @param[in] expiration time to delete the object after
	* @return true on success; false otherwise
	*/
	bool removeByKey(const std::string &master_key,
	const std::string &key,
	time_t expiration)
	{
	return memcached_success(memcached_delete_by_key(memc,
	master_key.c_str(),
	master_key.length(),
	key.c_str(),
	key.length(),
	expiration));
	}

	/**
	* Wipe the contents of memcached servers.
	*
	* @param[in] expiration time to wait until wiping contents of
	* memcached servers
	* @return true on success; false otherwise
	*/
	bool flush(time_t expiration= 0)
	{
	return memcached_success(memcached_flush(memc, expiration));
	}

	/**
	* Get the library version string.
	* @return std::string containing a copy of the library version string.
	*/
	const std::string libVersion() const
	{
	const char *ver= memcached_lib_version();
	const std::string version(ver);
	return version;
	}

	/**
	* Retrieve memcached statistics. Populate a std::map with the retrieved
	* stats. Each server will map to another std::map of the key:value stats
	.
	*
	* @param[out] stats_map a std::map to be populated with the memcached
	* stats
	* @return true on success; false otherwise
	*/
	bool getStats(std::map< std::string, std::map<std::string, std::string> >
	&stats_map)
	{
	memcached_return_t rc;
	memcached_stat_st *stats= memcached_stat(memc, NULL, &rc);

	if (rc != MEMCACHED_SUCCESS &&
	rc != MEMCACHED_SOME_ERRORS)
	{
	return false;
	}

	uint32_t server_count= memcached_server_count(memc);

	/*
	* For each memcached server, construct a std::map for its stats and ad
	d
	* it to the std::map of overall stats.
	*/
	for (uint32_t x= 0; x < server_count; x++)
	{
	memcached_server_instance_st instance=
	memcached_server_instance_by_position(memc, x);
	std::ostringstream strstm;
	std::string server_name(memcached_server_name(instance));
	server_name.append(":");
	strstm << memcached_server_port(instance);
	server_name.append(strstm.str());

	std::map<std::string, std::string> server_stats;
	char **list= NULL;
	char **ptr= NULL;

	list= memcached_stat_get_keys(memc, &stats[x], &rc);
	for (ptr= list; *ptr; ptr++)
	{
	char value= memcached_stat_get_value(memc, &stats[x], ptr, &rc);
	server_stats[*ptr]= value;
	free(value);
	}

	stats_map[server_name]= server_stats;
	free(list);
	}

	memcached_stat_free(memc, stats);
	return true;
	}

	private:
	memcached_st *memc;
	};

	}

End of changes. 4 change blocks.
	10 lines changed or deleted	32 lines changed or added

	pid.h	pid.h

	skipping to change at line 39	skipping to change at line 39
	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*	*
	*/	*/

	#pragma once	#pragma once


		#ifndef WIN32
		#include <netdb.h>
		#endif

		#include <sys/types.h>

	#ifdef __cplusplus	#ifdef __cplusplus
	extern "C" {	extern "C" {
	#endif	#endif

	LIBMEMCACHED_API	LIBMEMCACHED_API
	pid_t libmemcached_util_getpid(const char hostname, in_port_t port, memcac hed_return_t ret);	pid_t libmemcached_util_getpid(const char hostname, in_port_t port, memcac hed_return_t ret);

	LIBMEMCACHED_API	LIBMEMCACHED_API
	pid_t libmemcached_util_getpid2(const char hostname, in_port_t port, const char username, const char password, memcached_return_t ret);	pid_t libmemcached_util_getpid2(const char hostname, in_port_t port, const char username, const char password, memcached_return_t ret);


End of changes. 1 change blocks.
	0 lines changed or deleted	6 lines changed or added

	pool.h	pool.h

	skipping to change at line 40	skipping to change at line 40
	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*	*
	*/	*/

	#pragma once	#pragma once


	#include <libmemcached/memcached.h>	#include <libmemcached-1.0/memcached.h>

	#ifdef __cplusplus	#ifdef __cplusplus
	extern "C" {	extern "C" {
	#endif	#endif

	struct memcached_pool_st;	struct memcached_pool_st;
	typedef struct memcached_pool_st memcached_pool_st;	typedef struct memcached_pool_st memcached_pool_st;

	LIBMEMCACHED_API	LIBMEMCACHED_API
	memcached_pool_st memcached_pool_create(memcached_st mmc, uint32_t initia l, uint32_t max);	memcached_pool_st memcached_pool_create(memcached_st mmc, uint32_t initia l, uint32_t max);

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	server.h	server.h

	skipping to change at line 109	skipping to change at line 109
	extern "C" {	extern "C" {
	#endif	#endif

	LIBMEMCACHED_API	LIBMEMCACHED_API
	memcached_return_t memcached_server_cursor(const memcached_st *ptr,	memcached_return_t memcached_server_cursor(const memcached_st *ptr,
	const memcached_server_fn *callb ack,	const memcached_server_fn *callb ack,
	void *context,	void *context,
	uint32_t number_of_callbacks);	uint32_t number_of_callbacks);

	LIBMEMCACHED_API	LIBMEMCACHED_API

	memcached_server_instance_st memcached_server_by_key(const memcached_st *	memcached_server_instance_st memcached_server_by_key(memcached_st *ptr,
	ptr,	const char *key,
	const char *key,	size_t key_length,
	size_t key_length,	memcached_return_t *
	memcached_return_t	error);
	*error);

	LIBMEMCACHED_API	LIBMEMCACHED_API
	void memcached_server_error_reset(memcached_server_st *ptr);	void memcached_server_error_reset(memcached_server_st *ptr);

	LIBMEMCACHED_API	LIBMEMCACHED_API
	void memcached_server_free(memcached_server_st *ptr);	void memcached_server_free(memcached_server_st *ptr);

	LIBMEMCACHED_LOCAL	LIBMEMCACHED_LOCAL
	memcached_server_st memcached_server_clone(memcached_server_st destinatio n,	memcached_server_st memcached_server_clone(memcached_server_st destinatio n,
	memcached_server_st *source);	memcached_server_st *source);

End of changes. 1 change blocks.
	6 lines changed or deleted	5 lines changed or added

	storage.h	storage.h

	skipping to change at line 40	skipping to change at line 40
	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*	*
	*/	*/

	#pragma once	#pragma once


	#include "libmemcached/memcached.h"

	#ifdef __cplusplus	#ifdef __cplusplus
	extern "C" {	extern "C" {
	#endif	#endif

	/* All of the functions for adding data to the server */	/* All of the functions for adding data to the server */
	LIBMEMCACHED_API	LIBMEMCACHED_API
	memcached_return_t memcached_set(memcached_st ptr, const char key, size_t key_length,	memcached_return_t memcached_set(memcached_st ptr, const char key, size_t key_length,
	const char *value, size_t value_length,	const char *value, size_t value_length,
	time_t expiration,	time_t expiration,
	uint32_t flags);	uint32_t flags);

End of changes. 1 change blocks.
	2 lines changed or deleted	0 lines changed or added

	strerror.h	strerror.h
	/* HashKit	/* HashKit
	* Copyright (C) 2009 Brian Aker	* Copyright (C) 2009 Brian Aker
	* All rights reserved.	* All rights reserved.
	*	*
	* Use and distribution licensed under the BSD license. See	* Use and distribution licensed under the BSD license. See
	* the COPYING file in the parent directory for full text.	* the COPYING file in the parent directory for full text.
	*/	*/


	#ifndef HASHKIT_STRERROR_H	#pragma once
	#define HASHKIT_STRERROR_H

	#ifdef __cplusplus	#ifdef __cplusplus
	extern "C" {	extern "C" {
	#endif	#endif

	HASHKIT_API	HASHKIT_API
	const char hashkit_strerror(hashkit_st ptr, hashkit_return_t rc);	const char hashkit_strerror(hashkit_st ptr, hashkit_return_t rc);

	#ifdef __cplusplus	#ifdef __cplusplus
	}	}
	#endif	#endif


	#endif /* HASHKIT_STRERROR_H */

End of changes. 2 change blocks.
	2 lines changed or deleted	1 lines changed or added

	string.h	string.h

	skipping to change at line 40	skipping to change at line 40
	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*	*
	*/	*/

	#pragma once	#pragma once


	#include <libmemcached/basic_string.h>

	/**	/**
	Strings are always under our control so we make some assumptions	Strings are always under our control so we make some assumptions
	about them.	about them.

	1) is_initialized is always valid.	1) is_initialized is always valid.
	2) A string once intialized will always be, until free where we	2) A string once intialized will always be, until free where we
	unset this flag.	unset this flag.
	3) A string always has a root.	3) A string always has a root.
	*/	*/


End of changes. 1 change blocks.
	2 lines changed or deleted	0 lines changed or added

	vbucket.h	vbucket.h

	/* -- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil --	/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
	*/	*
	#ifndef MEMCACHED_VBUCKET_H	* Libmemcached library
	#define MEMCACHED_VBUCKET_H 1	*
		* Copyright (C) 2011 Data Differential, http://datadifferential.com/
		*
		* Redistribution and use in source and binary forms, with or without
		* modification, are permitted provided that the following conditions are
		* met:
		*
		* * Redistributions of source code must retain the above copyright
		* notice, this list of conditions and the following disclaimer.
		*
		* * Redistributions in binary form must reproduce the above
		* copyright notice, this list of conditions and the following disclaimer
		* in the documentation and/or other materials provided with the
		* distribution.
		*
		* * The names of its contributors may not be used to endorse or
		* promote products derived from this software without specific prior
		* written permission.
		*
		* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
		* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
		* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
		* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
		* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
		* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
		* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
		* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
		* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
		* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
		* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		*
		*/

		#pragma once

	#ifdef __cplusplus	#ifdef __cplusplus
	extern "C"	extern "C"
	{	{
	#endif	#endif

	typedef enum {	typedef enum {
	vbucket_state_active = 1, /*< Actively servicing a vbucket. /	vbucket_state_active = 1, /*< Actively servicing a vbucket. /
	vbucket_state_replica, /*< Servicing a vbucket as a replica only. /	vbucket_state_replica, /*< Servicing a vbucket as a replica only. /
	vbucket_state_pending, /*< Pending active. /	vbucket_state_pending, /*< Pending active. /

	skipping to change at line 26	skipping to change at line 60

	#define is_valid_vbucket_state_t(state) \	#define is_valid_vbucket_state_t(state) \
	(state == vbucket_state_active \|\| \	(state == vbucket_state_active \|\| \
	state == vbucket_state_replica \|\| \	state == vbucket_state_replica \|\| \
	state == vbucket_state_pending \|\| \	state == vbucket_state_pending \|\| \
	state == vbucket_state_dead)	state == vbucket_state_dead)

	#ifdef __cplusplus	#ifdef __cplusplus
	}	}
	#endif	#endif

	#endif

End of changes. 2 change blocks.
	4 lines changed or deleted	37 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/