-.TH "HASHKIT_CLONE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "HASHKIT_CLONE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
hashkit_clone \- libhashkit Documentation
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Create and destroy hashkit objects
-.SH LIBRARY
-.sp
-C Library for hashing algorithms (libmemcached, \-lhashkit)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/hashkit.h>
-
-hashkit_st *hashkit_create(hashkit_st *hash);
-
-hashkit_st *hashkit_clone(hashkit_st *destination, const hashkit_st *ptr);
-
-void hashkit_free(hashkit_st *hash);
-
-bool hashkit_is_allocated(const hashkit_st *hash);
-.ft P
-.fi
+#include <libhashkit/hashkit.h>
+.INDENT 0.0
+.TP
+.B hashkit_st *hashkit_create(hashkit_st *hash);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B hashkit_st *hashkit_clone(hashkit_st *destination, const hashkit_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void hashkit_free(hashkit_st *hash);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B bool hashkit_is_allocated(const hashkit_st *hash);
+.UNINDENT
+.sp
+Compile and link with \-lhashkit
.SH DESCRIPTION
.sp
The hashkit_create() function initializes a hashkit object for use. If
-.TH "HASHKIT_CRC32" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "HASHKIT_CRC32" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
hashkit_crc32 \- libhashkit Documentation
.
.
.sp
Various hash functions to use for calculating values for keys
-.SH LIBRARY
-.sp
-C Library for hashing algorithms (libmemcached, \-lhashkit)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/hashkit.h>
-
-uint32_t hashkit_default(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
-uint32_t hashkit_crc32(const char *key, size_t key_length);
-uint32_t hashkit_hsieh(const char *key, size_t key_length);
-uint32_t hashkit_murmur(const char *key, size_t key_length);
-uint32_t hashkit_jenkins(const char *key, size_t key_length);
-uint32_t hashkit_md5(const char *key, size_t key_length);
-.ft P
-.fi
+#include <libhashkit/hashkit.h>
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_default(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_crc32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_hsieh(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_murmur(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_jenkins(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_md5(const char *key, size_t key_length);
+.UNINDENT
+.sp
+Compile and link with \-lhashkit
.SH DESCRIPTION
.sp
These functions generate hash values from a key using a variety of
-.TH "HASHKIT_CREATE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "HASHKIT_CREATE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
hashkit_create \- libhashkit Documentation
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Create and destroy hashkit objects
-.SH LIBRARY
-.sp
-C Library for hashing algorithms (libmemcached, \-lhashkit)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/hashkit.h>
-
-hashkit_st *hashkit_create(hashkit_st *hash);
-
-hashkit_st *hashkit_clone(hashkit_st *destination, const hashkit_st *ptr);
-
-void hashkit_free(hashkit_st *hash);
-
-bool hashkit_is_allocated(const hashkit_st *hash);
-.ft P
-.fi
+#include <libhashkit/hashkit.h>
+.INDENT 0.0
+.TP
+.B hashkit_st *hashkit_create(hashkit_st *hash);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B hashkit_st *hashkit_clone(hashkit_st *destination, const hashkit_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void hashkit_free(hashkit_st *hash);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B bool hashkit_is_allocated(const hashkit_st *hash);
+.UNINDENT
+.sp
+Compile and link with \-lhashkit
.SH DESCRIPTION
.sp
The hashkit_create() function initializes a hashkit object for use. If
-.TH "HASHKIT_FNV1_32" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "HASHKIT_FNV1_32" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
hashkit_fnv1_32 \- libhashkit Documentation
.
.
.sp
Various hash functions to use for calculating values for keys
-.SH LIBRARY
-.sp
-C Library for hashing algorithms (libmemcached, \-lhashkit)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/hashkit.h>
-
-uint32_t hashkit_default(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
-uint32_t hashkit_crc32(const char *key, size_t key_length);
-uint32_t hashkit_hsieh(const char *key, size_t key_length);
-uint32_t hashkit_murmur(const char *key, size_t key_length);
-uint32_t hashkit_jenkins(const char *key, size_t key_length);
-uint32_t hashkit_md5(const char *key, size_t key_length);
-.ft P
-.fi
+#include <libhashkit/hashkit.h>
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_default(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_crc32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_hsieh(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_murmur(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_jenkins(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_md5(const char *key, size_t key_length);
+.UNINDENT
+.sp
+Compile and link with \-lhashkit
.SH DESCRIPTION
.sp
These functions generate hash values from a key using a variety of
-.TH "HASHKIT_FNV1_64" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "HASHKIT_FNV1_64" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
hashkit_fnv1_64 \- libhashkit Documentation
.
.
.sp
Various hash functions to use for calculating values for keys
-.SH LIBRARY
-.sp
-C Library for hashing algorithms (libmemcached, \-lhashkit)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/hashkit.h>
-
-uint32_t hashkit_default(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
-uint32_t hashkit_crc32(const char *key, size_t key_length);
-uint32_t hashkit_hsieh(const char *key, size_t key_length);
-uint32_t hashkit_murmur(const char *key, size_t key_length);
-uint32_t hashkit_jenkins(const char *key, size_t key_length);
-uint32_t hashkit_md5(const char *key, size_t key_length);
-.ft P
-.fi
+#include <libhashkit/hashkit.h>
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_default(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_crc32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_hsieh(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_murmur(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_jenkins(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_md5(const char *key, size_t key_length);
+.UNINDENT
+.sp
+Compile and link with \-lhashkit
.SH DESCRIPTION
.sp
These functions generate hash values from a key using a variety of
-.TH "HASHKIT_FNV1A_32" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "HASHKIT_FNV1A_32" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
hashkit_fnv1a_32 \- libhashkit Documentation
.
.
.sp
Various hash functions to use for calculating values for keys
-.SH LIBRARY
-.sp
-C Library for hashing algorithms (libmemcached, \-lhashkit)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/hashkit.h>
-
-uint32_t hashkit_default(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
-uint32_t hashkit_crc32(const char *key, size_t key_length);
-uint32_t hashkit_hsieh(const char *key, size_t key_length);
-uint32_t hashkit_murmur(const char *key, size_t key_length);
-uint32_t hashkit_jenkins(const char *key, size_t key_length);
-uint32_t hashkit_md5(const char *key, size_t key_length);
-.ft P
-.fi
+#include <libhashkit/hashkit.h>
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_default(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_crc32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_hsieh(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_murmur(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_jenkins(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_md5(const char *key, size_t key_length);
+.UNINDENT
+.sp
+Compile and link with \-lhashkit
.SH DESCRIPTION
.sp
These functions generate hash values from a key using a variety of
-.TH "HASHKIT_FNV1A_64" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "HASHKIT_FNV1A_64" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
hashkit_fnv1a_64 \- libhashkit Documentation
.
.
.sp
Various hash functions to use for calculating values for keys
-.SH LIBRARY
-.sp
-C Library for hashing algorithms (libmemcached, \-lhashkit)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/hashkit.h>
-
-uint32_t hashkit_default(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
-uint32_t hashkit_crc32(const char *key, size_t key_length);
-uint32_t hashkit_hsieh(const char *key, size_t key_length);
-uint32_t hashkit_murmur(const char *key, size_t key_length);
-uint32_t hashkit_jenkins(const char *key, size_t key_length);
-uint32_t hashkit_md5(const char *key, size_t key_length);
-.ft P
-.fi
+#include <libhashkit/hashkit.h>
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_default(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_crc32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_hsieh(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_murmur(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_jenkins(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_md5(const char *key, size_t key_length);
+.UNINDENT
+.sp
+Compile and link with \-lhashkit
.SH DESCRIPTION
.sp
These functions generate hash values from a key using a variety of
-.TH "HASHKIT_FREE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "HASHKIT_FREE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
hashkit_free \- libhashkit Documentation
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Create and destroy hashkit objects
-.SH LIBRARY
-.sp
-C Library for hashing algorithms (libmemcached, \-lhashkit)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/hashkit.h>
-
-hashkit_st *hashkit_create(hashkit_st *hash);
-
-hashkit_st *hashkit_clone(hashkit_st *destination, const hashkit_st *ptr);
-
-void hashkit_free(hashkit_st *hash);
-
-bool hashkit_is_allocated(const hashkit_st *hash);
-.ft P
-.fi
+#include <libhashkit/hashkit.h>
+.INDENT 0.0
+.TP
+.B hashkit_st *hashkit_create(hashkit_st *hash);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B hashkit_st *hashkit_clone(hashkit_st *destination, const hashkit_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void hashkit_free(hashkit_st *hash);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B bool hashkit_is_allocated(const hashkit_st *hash);
+.UNINDENT
+.sp
+Compile and link with \-lhashkit
.SH DESCRIPTION
.sp
The hashkit_create() function initializes a hashkit object for use. If
-.TH "HASHKIT_FUNCTIONS" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "HASHKIT_FUNCTIONS" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
hashkit_functions \- libhashkit Documentation
.
.
.sp
Various hash functions to use for calculating values for keys
-.SH LIBRARY
-.sp
-C Library for hashing algorithms (libmemcached, \-lhashkit)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/hashkit.h>
-
-uint32_t hashkit_default(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
-uint32_t hashkit_crc32(const char *key, size_t key_length);
-uint32_t hashkit_hsieh(const char *key, size_t key_length);
-uint32_t hashkit_murmur(const char *key, size_t key_length);
-uint32_t hashkit_jenkins(const char *key, size_t key_length);
-uint32_t hashkit_md5(const char *key, size_t key_length);
-.ft P
-.fi
+#include <libhashkit/hashkit.h>
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_default(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_crc32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_hsieh(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_murmur(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_jenkins(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_md5(const char *key, size_t key_length);
+.UNINDENT
+.sp
+Compile and link with \-lhashkit
.SH DESCRIPTION
.sp
These functions generate hash values from a key using a variety of
-.TH "HASHKIT_HSIEH" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "HASHKIT_HSIEH" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
hashkit_hsieh \- libhashkit Documentation
.
.
.sp
Various hash functions to use for calculating values for keys
-.SH LIBRARY
-.sp
-C Library for hashing algorithms (libmemcached, \-lhashkit)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/hashkit.h>
-
-uint32_t hashkit_default(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
-uint32_t hashkit_crc32(const char *key, size_t key_length);
-uint32_t hashkit_hsieh(const char *key, size_t key_length);
-uint32_t hashkit_murmur(const char *key, size_t key_length);
-uint32_t hashkit_jenkins(const char *key, size_t key_length);
-uint32_t hashkit_md5(const char *key, size_t key_length);
-.ft P
-.fi
+#include <libhashkit/hashkit.h>
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_default(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_crc32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_hsieh(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_murmur(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_jenkins(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_md5(const char *key, size_t key_length);
+.UNINDENT
+.sp
+Compile and link with \-lhashkit
.SH DESCRIPTION
.sp
These functions generate hash values from a key using a variety of
-.TH "HASHKIT_IS_ALLOCATED" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "HASHKIT_IS_ALLOCATED" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
hashkit_is_allocated \- libhashkit Documentation
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Create and destroy hashkit objects
-.SH LIBRARY
-.sp
-C Library for hashing algorithms (libmemcached, \-lhashkit)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/hashkit.h>
-
-hashkit_st *hashkit_create(hashkit_st *hash);
-
-hashkit_st *hashkit_clone(hashkit_st *destination, const hashkit_st *ptr);
-
-void hashkit_free(hashkit_st *hash);
-
-bool hashkit_is_allocated(const hashkit_st *hash);
-.ft P
-.fi
+#include <libhashkit/hashkit.h>
+.INDENT 0.0
+.TP
+.B hashkit_st *hashkit_create(hashkit_st *hash);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B hashkit_st *hashkit_clone(hashkit_st *destination, const hashkit_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void hashkit_free(hashkit_st *hash);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B bool hashkit_is_allocated(const hashkit_st *hash);
+.UNINDENT
+.sp
+Compile and link with \-lhashkit
.SH DESCRIPTION
.sp
The hashkit_create() function initializes a hashkit object for use. If
-.TH "HASHKIT_JENKINS" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "HASHKIT_JENKINS" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
hashkit_jenkins \- libhashkit Documentation
.
.
.sp
Various hash functions to use for calculating values for keys
-.SH LIBRARY
-.sp
-C Library for hashing algorithms (libmemcached, \-lhashkit)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/hashkit.h>
-
-uint32_t hashkit_default(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
-uint32_t hashkit_crc32(const char *key, size_t key_length);
-uint32_t hashkit_hsieh(const char *key, size_t key_length);
-uint32_t hashkit_murmur(const char *key, size_t key_length);
-uint32_t hashkit_jenkins(const char *key, size_t key_length);
-uint32_t hashkit_md5(const char *key, size_t key_length);
-.ft P
-.fi
+#include <libhashkit/hashkit.h>
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_default(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_crc32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_hsieh(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_murmur(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_jenkins(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_md5(const char *key, size_t key_length);
+.UNINDENT
+.sp
+Compile and link with \-lhashkit
.SH DESCRIPTION
.sp
These functions generate hash values from a key using a variety of
-.TH "HASHKIT_MD5" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "HASHKIT_MD5" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
hashkit_md5 \- libhashkit Documentation
.
.
.sp
Various hash functions to use for calculating values for keys
-.SH LIBRARY
-.sp
-C Library for hashing algorithms (libmemcached, \-lhashkit)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/hashkit.h>
-
-uint32_t hashkit_default(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
-uint32_t hashkit_crc32(const char *key, size_t key_length);
-uint32_t hashkit_hsieh(const char *key, size_t key_length);
-uint32_t hashkit_murmur(const char *key, size_t key_length);
-uint32_t hashkit_jenkins(const char *key, size_t key_length);
-uint32_t hashkit_md5(const char *key, size_t key_length);
-.ft P
-.fi
+#include <libhashkit/hashkit.h>
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_default(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_crc32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_hsieh(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_murmur(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_jenkins(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_md5(const char *key, size_t key_length);
+.UNINDENT
+.sp
+Compile and link with \-lhashkit
.SH DESCRIPTION
.sp
These functions generate hash values from a key using a variety of
-.TH "HASHKIT_MURMUR" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "HASHKIT_MURMUR" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
hashkit_murmur \- libhashkit Documentation
.
.
.sp
Various hash functions to use for calculating values for keys
-.SH LIBRARY
-.sp
-C Library for hashing algorithms (libmemcached, \-lhashkit)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/hashkit.h>
-
-uint32_t hashkit_default(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
-uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
-uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
-uint32_t hashkit_crc32(const char *key, size_t key_length);
-uint32_t hashkit_hsieh(const char *key, size_t key_length);
-uint32_t hashkit_murmur(const char *key, size_t key_length);
-uint32_t hashkit_jenkins(const char *key, size_t key_length);
-uint32_t hashkit_md5(const char *key, size_t key_length);
-.ft P
-.fi
+#include <libhashkit/hashkit.h>
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_default(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_64(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_fnv1a_32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_crc32(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_hsieh(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_murmur(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_jenkins(const char *key, size_t key_length);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_md5(const char *key, size_t key_length);
+.UNINDENT
+.sp
+Compile and link with \-lhashkit
.SH DESCRIPTION
.sp
These functions generate hash values from a key using a variety of
-.TH "HASHKIT_VALUE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "HASHKIT_VALUE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
hashkit_value \- libhashkit Documentation
.
.
.sp
Generate a value for the given key
-.SH LIBRARY
-.sp
-C Library for hashing algorithms (libmemcached, \-lhashkit)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/hashkit.h>
-
-uint32_t hashkit_value(hashkit_st *hash,
- const char *key,
- size_t key_length);
-.ft P
-.fi
+#include <libhashkit/hashkit.h>
+.INDENT 0.0
+.TP
+.B uint32_t hashkit_value(hashkit_st *hash, const char *key, size_t key_length);
+.UNINDENT
+.sp
+Compile and link with \-lhashkit
.SH DESCRIPTION
.sp
The hashkit_value() function generates a 32\-bit hash value from the
-.TH "LIBHASHKIT" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "LIBHASHKIT" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
libhashkit \- libhashkit Documentation
.
..
.\" Man page generated from reStructeredText.
.
-.SH LIBRARY
-.sp
-C library collection of useful hashing algorithm (libhashkit, \-lhashkit)
-.SH SYNOPSIS
.sp
.nf
.ft C
\fI\%http://libmemcached.org/\fP
.SH SEE ALSO
.sp
-\fIlibmemcached(3)\fP
+\fIlibhashkit(3)\fP
.SH AUTHOR
Brian Aker
.SH COPYRIGHT
-.TH "LIBMEMCACHED" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "LIBMEMCACHED" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
libmemcached \- Introducing the C Client Library for memcached
.
#include <libmemcached/memcached.h>
.sp
Compile and link with \-lmemcached
+.sp
+libMemcached is an open source C/C++ client library and tools for the memcached server (\fI\%http://danga.com/memcached\fP). It has been designed to be light on memory usage, thread safe, and provide full access to server side methods.
+.sp
+libMemcached was designed to provide the greatest number of options to use Memcached. Some of the features provided:
+.INDENT 0.0
+.IP 1. 3
+.
+Asynchronous and Synchronous Transport Support.
+.IP 2. 3
+.
+Consistent Hashing and Distribution.
+.IP 3. 3
+.
+Tunable Hashing algorithm to match keys.
+.IP 4. 3
+.
+Access to large object support.
+.IP 5. 3
+.
+Local replication.
+.IP 6. 3
+.
+A complete reference guide and documentation to the API.
+.IP 7. 3
+.
+Tools to Manage your Memcached networks.
+.UNINDENT
.SH DESCRIPTION
.sp
"Memcached is a high\-performance, distributed memory object caching
applications by alleviating database load." \fI\%http://danga.com/memcached/\fP
.sp
\fBlibmemcached\fP is a small, thread\-safe client library for the
-memcached protocol. The code has all been written with an eye to allow
+memcached protocol. The code has all been written to allow
for both web and embedded usage. It handles the work behind routing
-particular keys to specific servers that you specify (and values are
-matched based on server order as supplied by you). It implements both
-a modula and consistent method of object distribution.
+individual keys to specific servers specified by the developer (and values are
+matched based on server order as supplied by the user). It implements
+a modular and consistent method of object distribution.
.sp
There are multiple implemented routing and hashing methods. See the
-memcached_behavior_set() manpage.
+memcached_behavior_set() manpage for more information.
.sp
All operations are performed against a \fBmemcached_st\fP structure.
These structures can either be dynamically allocated or statically
.UNINDENT
.SH THREADS AND PROCESSES
.sp
-When using threads or forked processes it is important to keep an instance
+When using threads or forked processes it is important to keep one instance
of \fBmemcached_st\fP per process or thread. Without creating your own locking
-structures you can not share a single \fBmemcached_st\fP. You can though call
+structures you can not share a single \fBmemcached_st\fP. However, you can call
memcached_quit(3) on a \fBmemcached_st\fP and then use the resulting cloned
structure.
.SH HOME
-.TH "LIBMEMCACHED_CHECK_CONFIGURATION" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "LIBMEMCACHED_CHECK_CONFIGURATION" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
libmemcached_check_configuration \- libmemcached Documentation
.
.\" Man page generated from reStructeredText.
.
.SH SYNOPSIS
+.sp
+#include <libmemcached/memcached.h>
.INDENT 0.0
.TP
.B memcached_st *memcached(const char\fI\ *string\fP, size_t\fI\ string_length\fP)
-.TH "LIBMEMCACHED_CONFIGURATION" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "LIBMEMCACHED_CONFIGURATION" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
libmemcached_configuration \- libmemcached Documentation
.
.\" Man page generated from reStructeredText.
.
.SH SYNOPSIS
+.sp
+#include <libmemcached/memcached.h>
.INDENT 0.0
.TP
.B memcached_st *memcached(const char\fI\ *string\fP, size_t\fI\ string_length\fP)
-.TH "LIBMEMCACHED_EXAMPLES" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "LIBMEMCACHED_EXAMPLES" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
libmemcached_examples \- libmemcached Documentation
.
-.TH "LIBMEMCACHEDUTIL" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "LIBMEMCACHEDUTIL" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
libmemcachedutil \- libmemcached Documentation
.
.
.sp
Utility library for libmemcached
-.SH LIBRARY
-.sp
-C Client Library containing utility functions for libmemcached (libmemcachedutil, \-lmemcachedutil \-lmemcached)
.SH SYNOPSIS
.sp
.nf
-.TH "MEMASLAP" "1" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMASLAP" "1" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memaslap \- libmemcached Documentation
.
-.TH "MEMCACHED" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached \- libmemcached Documentation
.
.\" Man page generated from reStructeredText.
.
.SH SYNOPSIS
+.sp
+#include <libmemcached/memcached.h>
.INDENT 0.0
.TP
.B memcached_st *memcached(const char\fI\ *string\fP, size_t\fI\ string_length\fP)
-.TH "MEMCACHED_ADD" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_ADD" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_add \- Storing and Replacing Data
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Store value on server
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.UNINDENT
.INDENT 0.0
.TP
-.B memcached_return_t memcached_prepend(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas(memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_set_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
.INDENT 0.0
.TP
.B memcached_return_t memcached_replace_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_prepend_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
.sp
Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
memcached_set(), memcached_add(), and memcached_replace() are all used to
store information on the server. All methods take a key, and its length to
-store the object. Keys are currently limited to 250 characters by the
-memcached(1) server. You must also supply a value and a length. Optionally you
-may tests an expiration time for the object and a 16 byte value (it is
-meant to be used as a bitmap).
+store the object. Keys are currently limited to 250 characters when using either a version of memcached(1) which is 1.4 or below, or when using the text protocol.
+You must supply both a value and a length. Optionally you
+may test an expiration time for the object and a 16 byte value (it is
+meant to be used as a bitmap). "flags" is a 4byte space that is stored alongside of the main value. Many sub libraries make use of this field, so in most cases users should avoid making use of it.
.sp
memcached_set() will write an object to the server. If an object already
exists it will overwrite what is in the server. If the object does not exist
memcached_add() adds an object to the server. If the object is found on the
server an error occurs, otherwise the value is stored.
.sp
-memcached_prepend() places a segment of data before the last piece of data
-stored. Currently expiration and key are not used in the server.
-.sp
-memcached_append() places a segment of data at the end of the last piece of
-data stored. Currently expiration and key are not used in the server.
-.sp
memcached_cas() overwrites data in the server as long as the "cas" value is
still the same in the server. You can get the cas value of a result by
calling memcached_result_cas() on a memcached_result_st(3) structure. At the point
for it in libmemcached(3) is optional. Please see memcached_set() for
information on how to do this.
.sp
-memcached_set_by_key(), memcached_add_by_key(), memcached_replace_by_key(),
-memcached_prepend_by_key(), memcached_append_by_key_by_key(),
-memcached_cas_by_key() methods all behave in a similar method as the non key
+memcached_set_by_key(), memcached_add_by_key(), and memcached_replace_by_key()
+methods all behave in a similar method as the non key
methods. The difference is that they use their group_key parameter to map
objects to particular servers.
.sp
If you are looking for performance, memcached_set() with non\-blocking IO is
the fastest way to store data on the server.
.sp
-All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. But when using these operations with this behavior on, there
+All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. However, when using these operations with this behavior on, there
are limits to the size of the payload being sent to the server. The reason for
-these limits is that the Memcahed Server does not allow multi\-datagram requests
+these limits is that the Memcached Server does not allow multi\-datagram requests
and the current server implementation sets a datagram size to 1400 bytes. Due
to protocol overhead, the actual limit of the user supplied data is less than
-1400 bytes and depends on the protocol in use as well as the operation being
+1400 bytes and depends on the protocol in use as, well as the operation being
executed. When running with the binary protocol, \(ga\(ga MEMCACHED_BEHAVIOR_BINARY_PROTOCOL\(ga\(ga,
the size of the key,value, flags and expiry combined may not exceed 1368 bytes.
When running with the ASCII protocol, the exact limit fluctuates depending on
\fI\%http://libmemcached.org/\fP
.SH SEE ALSO
.sp
-memcached(1) libmemached(3) memcached_strerror(3)
+memcached(1) libmemached(3) memcached_strerror(3) memcached_prepend(3) memcached_cas(3) memcached_append(3)
.SH AUTHOR
Brian Aker
.SH COPYRIGHT
-.TH "MEMCACHED_ADD_BY_KEY" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_ADD_BY_KEY" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_add_by_key \- Storing and Replacing Data
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Store value on server
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.UNINDENT
.INDENT 0.0
.TP
-.B memcached_return_t memcached_prepend(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas(memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_set_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
.INDENT 0.0
.TP
.B memcached_return_t memcached_replace_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_prepend_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
.sp
Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
memcached_set(), memcached_add(), and memcached_replace() are all used to
store information on the server. All methods take a key, and its length to
-store the object. Keys are currently limited to 250 characters by the
-memcached(1) server. You must also supply a value and a length. Optionally you
-may tests an expiration time for the object and a 16 byte value (it is
-meant to be used as a bitmap).
+store the object. Keys are currently limited to 250 characters when using either a version of memcached(1) which is 1.4 or below, or when using the text protocol.
+You must supply both a value and a length. Optionally you
+may test an expiration time for the object and a 16 byte value (it is
+meant to be used as a bitmap). "flags" is a 4byte space that is stored alongside of the main value. Many sub libraries make use of this field, so in most cases users should avoid making use of it.
.sp
memcached_set() will write an object to the server. If an object already
exists it will overwrite what is in the server. If the object does not exist
memcached_add() adds an object to the server. If the object is found on the
server an error occurs, otherwise the value is stored.
.sp
-memcached_prepend() places a segment of data before the last piece of data
-stored. Currently expiration and key are not used in the server.
-.sp
-memcached_append() places a segment of data at the end of the last piece of
-data stored. Currently expiration and key are not used in the server.
-.sp
memcached_cas() overwrites data in the server as long as the "cas" value is
still the same in the server. You can get the cas value of a result by
calling memcached_result_cas() on a memcached_result_st(3) structure. At the point
for it in libmemcached(3) is optional. Please see memcached_set() for
information on how to do this.
.sp
-memcached_set_by_key(), memcached_add_by_key(), memcached_replace_by_key(),
-memcached_prepend_by_key(), memcached_append_by_key_by_key(),
-memcached_cas_by_key() methods all behave in a similar method as the non key
+memcached_set_by_key(), memcached_add_by_key(), and memcached_replace_by_key()
+methods all behave in a similar method as the non key
methods. The difference is that they use their group_key parameter to map
objects to particular servers.
.sp
If you are looking for performance, memcached_set() with non\-blocking IO is
the fastest way to store data on the server.
.sp
-All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. But when using these operations with this behavior on, there
+All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. However, when using these operations with this behavior on, there
are limits to the size of the payload being sent to the server. The reason for
-these limits is that the Memcahed Server does not allow multi\-datagram requests
+these limits is that the Memcached Server does not allow multi\-datagram requests
and the current server implementation sets a datagram size to 1400 bytes. Due
to protocol overhead, the actual limit of the user supplied data is less than
-1400 bytes and depends on the protocol in use as well as the operation being
+1400 bytes and depends on the protocol in use as, well as the operation being
executed. When running with the binary protocol, \(ga\(ga MEMCACHED_BEHAVIOR_BINARY_PROTOCOL\(ga\(ga,
the size of the key,value, flags and expiry combined may not exceed 1368 bytes.
When running with the ASCII protocol, the exact limit fluctuates depending on
\fI\%http://libmemcached.org/\fP
.SH SEE ALSO
.sp
-memcached(1) libmemached(3) memcached_strerror(3)
+memcached(1) libmemached(3) memcached_strerror(3) memcached_prepend(3) memcached_cas(3) memcached_append(3)
.SH AUTHOR
Brian Aker
.SH COPYRIGHT
-.TH "MEMCACHED_ANALYZE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_ANALYZE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_analyze \- libmemcached Documentation
.
.
.sp
Analyze server information
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-memcached_analysis_st *
- memcached_analyze (memcached_st *ptr,
- memcached_stat_st *stat,
- memcached_return_t *error);
-.ft P
-.fi
+.INDENT 0.0
+.TP
+.B memcached_analysis_st * memcached_analyze (memcached_st *ptr, memcached_stat_st *stat, memcached_return_t *error);
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) has the ability to query a memcached server (or collection
-.TH "MEMCACHED_APPEND" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_APPEND" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
-memcached_append \- Storing and Replacing Data
+memcached_append \- Appending to or Prepending to data on the server
.
.nr rst2man-indent-level 0
.
.\" Man page generated from reStructeredText.
.
.sp
-Store value on server
+Appending or Prepending to data on the server
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.INDENT 0.0
.TP
-.B memcached_return_t memcached_set (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_add (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_replace (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_prepend(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
.UNINDENT
.INDENT 0.0
.UNINDENT
.INDENT 0.0
.TP
-.B memcached_return_t memcached_cas(memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_set_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_add_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_replace_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_prepend_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
.INDENT 0.0
.TP
.B memcached_return_t memcached_append_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
.sp
Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
-memcached_set(), memcached_add(), and memcached_replace() are all used to
-store information on the server. All methods take a key, and its length to
-store the object. Keys are currently limited to 250 characters by the
-memcached(1) server. You must also supply a value and a length. Optionally you
-may tests an expiration time for the object and a 16 byte value (it is
-meant to be used as a bitmap).
-.sp
-memcached_set() will write an object to the server. If an object already
-exists it will overwrite what is in the server. If the object does not exist
-it will be written. If you are using the non\-blocking mode this function
-will always return true unless a network error occurs.
-.sp
-memcached_replace() replaces an object on the server. If the object is not
-found on the server an error occurs.
-.sp
-memcached_add() adds an object to the server. If the object is found on the
-server an error occurs, otherwise the value is stored.
+memcached_prepend() and memcached_append are used to
+modify information on a server. All methods take a key, and its length to
+store the object. Keys are currently limited to 250 characters when using either a version of memcached(1) which is 1.4 or below, or when using the text protocol.
+You must supply both a value and a length. Optionally you
+may test an expiration time for the object and a 16 byte value (it is
+meant to be used as a bitmap). "flags" is a 4byte space that is stored alongside of the main value. Many sub libraries make use of this field, so in most cases users should avoid making use of it.
.sp
memcached_prepend() places a segment of data before the last piece of data
stored. Currently expiration and key are not used in the server.
memcached_append() places a segment of data at the end of the last piece of
data stored. Currently expiration and key are not used in the server.
.sp
-memcached_cas() overwrites data in the server as long as the "cas" value is
-still the same in the server. You can get the cas value of a result by
-calling memcached_result_cas() on a memcached_result_st(3) structure. At the point
-that this note was written cas is still buggy in memached. Turning on tests
-for it in libmemcached(3) is optional. Please see memcached_set() for
-information on how to do this.
-.sp
-memcached_set_by_key(), memcached_add_by_key(), memcached_replace_by_key(),
-memcached_prepend_by_key(), memcached_append_by_key_by_key(),
-memcached_cas_by_key() methods all behave in a similar method as the non key
+memcached_prepend_by_key() and memcached_append_by_key_by_key(,
+methods both behave in a similar method as the non key
methods. The difference is that they use their group_key parameter to map
objects to particular servers.
.sp
If you are looking for performance, memcached_set() with non\-blocking IO is
the fastest way to store data on the server.
.sp
-All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. But when using these operations with this behavior on, there
+All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. However, when using these operations with this behavior on, there
are limits to the size of the payload being sent to the server. The reason for
-these limits is that the Memcahed Server does not allow multi\-datagram requests
+these limits is that the Memcached Server does not allow multi\-datagram requests
and the current server implementation sets a datagram size to 1400 bytes. Due
to protocol overhead, the actual limit of the user supplied data is less than
-1400 bytes and depends on the protocol in use as well as the operation being
+1400 bytes and depends on the protocol in use as, well as the operation being
executed. When running with the binary protocol, \(ga\(ga MEMCACHED_BEHAVIOR_BINARY_PROTOCOL\(ga\(ga,
the size of the key,value, flags and expiry combined may not exceed 1368 bytes.
When running with the ASCII protocol, the exact limit fluctuates depending on
All methods return a value of type \fBmemcached_return_t\fP.
On success the value will be \fBMEMCACHED_SUCCESS\fP.
Use memcached_strerror() to translate this value to a printable string.
-.sp
-For memcached_replace() and memcached_add(), \fBMEMCACHED_NOTSTORED\fP is a
-legitmate error in the case of a collision.
.SH HOME
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
.SH SEE ALSO
.sp
-memcached(1) libmemached(3) memcached_strerror(3)
+memcached(1) libmemached(3) memcached_strerror(3) memcached_set(3) memcached_add(3) memcached_cas(3) memcached_replace(3)
.SH AUTHOR
Brian Aker
.SH COPYRIGHT
-.TH "MEMCACHED_APPEND_BY_KEY" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_APPEND_BY_KEY" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
-memcached_append_by_key \- Storing and Replacing Data
+memcached_append_by_key \- Appending to or Prepending to data on the server
.
.nr rst2man-indent-level 0
.
.\" Man page generated from reStructeredText.
.
.sp
-Store value on server
+Appending or Prepending to data on the server
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.INDENT 0.0
.TP
-.B memcached_return_t memcached_set (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_add (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_replace (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_prepend(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
.UNINDENT
.INDENT 0.0
.UNINDENT
.INDENT 0.0
.TP
-.B memcached_return_t memcached_cas(memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_set_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_add_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_replace_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_prepend_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
.INDENT 0.0
.TP
.B memcached_return_t memcached_append_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
.sp
Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
-memcached_set(), memcached_add(), and memcached_replace() are all used to
-store information on the server. All methods take a key, and its length to
-store the object. Keys are currently limited to 250 characters by the
-memcached(1) server. You must also supply a value and a length. Optionally you
-may tests an expiration time for the object and a 16 byte value (it is
-meant to be used as a bitmap).
-.sp
-memcached_set() will write an object to the server. If an object already
-exists it will overwrite what is in the server. If the object does not exist
-it will be written. If you are using the non\-blocking mode this function
-will always return true unless a network error occurs.
-.sp
-memcached_replace() replaces an object on the server. If the object is not
-found on the server an error occurs.
-.sp
-memcached_add() adds an object to the server. If the object is found on the
-server an error occurs, otherwise the value is stored.
+memcached_prepend() and memcached_append are used to
+modify information on a server. All methods take a key, and its length to
+store the object. Keys are currently limited to 250 characters when using either a version of memcached(1) which is 1.4 or below, or when using the text protocol.
+You must supply both a value and a length. Optionally you
+may test an expiration time for the object and a 16 byte value (it is
+meant to be used as a bitmap). "flags" is a 4byte space that is stored alongside of the main value. Many sub libraries make use of this field, so in most cases users should avoid making use of it.
.sp
memcached_prepend() places a segment of data before the last piece of data
stored. Currently expiration and key are not used in the server.
memcached_append() places a segment of data at the end of the last piece of
data stored. Currently expiration and key are not used in the server.
.sp
-memcached_cas() overwrites data in the server as long as the "cas" value is
-still the same in the server. You can get the cas value of a result by
-calling memcached_result_cas() on a memcached_result_st(3) structure. At the point
-that this note was written cas is still buggy in memached. Turning on tests
-for it in libmemcached(3) is optional. Please see memcached_set() for
-information on how to do this.
-.sp
-memcached_set_by_key(), memcached_add_by_key(), memcached_replace_by_key(),
-memcached_prepend_by_key(), memcached_append_by_key_by_key(),
-memcached_cas_by_key() methods all behave in a similar method as the non key
+memcached_prepend_by_key() and memcached_append_by_key_by_key(,
+methods both behave in a similar method as the non key
methods. The difference is that they use their group_key parameter to map
objects to particular servers.
.sp
If you are looking for performance, memcached_set() with non\-blocking IO is
the fastest way to store data on the server.
.sp
-All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. But when using these operations with this behavior on, there
+All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. However, when using these operations with this behavior on, there
are limits to the size of the payload being sent to the server. The reason for
-these limits is that the Memcahed Server does not allow multi\-datagram requests
+these limits is that the Memcached Server does not allow multi\-datagram requests
and the current server implementation sets a datagram size to 1400 bytes. Due
to protocol overhead, the actual limit of the user supplied data is less than
-1400 bytes and depends on the protocol in use as well as the operation being
+1400 bytes and depends on the protocol in use as, well as the operation being
executed. When running with the binary protocol, \(ga\(ga MEMCACHED_BEHAVIOR_BINARY_PROTOCOL\(ga\(ga,
the size of the key,value, flags and expiry combined may not exceed 1368 bytes.
When running with the ASCII protocol, the exact limit fluctuates depending on
All methods return a value of type \fBmemcached_return_t\fP.
On success the value will be \fBMEMCACHED_SUCCESS\fP.
Use memcached_strerror() to translate this value to a printable string.
-.sp
-For memcached_replace() and memcached_add(), \fBMEMCACHED_NOTSTORED\fP is a
-legitmate error in the case of a collision.
.SH HOME
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
.SH SEE ALSO
.sp
-memcached(1) libmemached(3) memcached_strerror(3)
+memcached(1) libmemached(3) memcached_strerror(3) memcached_set(3) memcached_add(3) memcached_cas(3) memcached_replace(3)
.SH AUTHOR
Brian Aker
.SH COPYRIGHT
-.TH "MEMCACHED_AUTO" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_AUTO" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_auto \- Incrementing and Decrementing Values
.
-.TH "MEMCACHED_BEHAVIOR" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_BEHAVIOR" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_behavior \- libmemcached Documentation
.
.\" Man page generated from reStructeredText.
.
.sp
-Manipulate behavior
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
+Manipulate the behavior of a memcached_st structure.
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.TP
.B memcached_return_t memcached_behavior_set (memcached_st *ptr, memcached_behavior flag, uint64_t data);
.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
\fIlibmemcached(3)\fP behavior can be modified by use memcached_behavior_set().
-.TH "MEMCACHED_BEHAVIOR_GET" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_BEHAVIOR_GET" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_behavior_get \- libmemcached Documentation
.
.\" Man page generated from reStructeredText.
.
.sp
-Manipulate behavior
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
+Manipulate the behavior of a memcached_st structure.
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.TP
.B memcached_return_t memcached_behavior_set (memcached_st *ptr, memcached_behavior flag, uint64_t data);
.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
\fIlibmemcached(3)\fP behavior can be modified by use memcached_behavior_set().
-.TH "MEMCACHED_BEHAVIOR_SET" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_BEHAVIOR_SET" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_behavior_set \- libmemcached Documentation
.
.\" Man page generated from reStructeredText.
.
.sp
-Manipulate behavior
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
+Manipulate the behavior of a memcached_st structure.
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.TP
.B memcached_return_t memcached_behavior_set (memcached_st *ptr, memcached_behavior flag, uint64_t data);
.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
\fIlibmemcached(3)\fP behavior can be modified by use memcached_behavior_set().
-.TH "MEMCACHED_CALLBACK" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_CALLBACK" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_callback \- libmemcached Documentation
.
.
.sp
Get and set a callback
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.TP
.B void * memcached_callback_get (memcached_st *ptr, memcached_callback_t flag, memcached_return_t *error);
.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) can have callbacks set key execution points. These either
memcached_callback_set() changes the function/structure assigned by a
callback flag. No connections are reset.
.sp
-You can use MEMCACHED_CALLBACK_USER_DATA to provide custom context if required for any
-of the callbacks
+You can use MEMCACHED_CALLBACK_USER_DATA to provide custom context if required for any of the callbacks.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_CLEANUP_FUNCTION
-.
-When memcached_delete() is called this function will be excuted. At the
-point of its execution all connections have been closed.
.UNINDENT
+.sp
+When memcached_delete() is called this function will be excuted. At the point of its execution all connections are closed.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_CLONE_FUNCTION
-.
-When memcached_delete() is called this function will be excuted. At the
-point of its execution all connections have been closed.
.UNINDENT
+.sp
+When memcached_delete() is called this function will be excuted. At the
+point of its execution all connections are closed.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_PREFIX_KEY
-.
+.UNINDENT
+.sp
You can set a value which will be used to create a domain for your keys.
-The value specified here will be prefixed to each of your keys. The value can not
-be greater then MEMCACHED_PREFIX_KEY_MAX_SIZE \- 1 and will reduce MEMCACHED_MAX_KEY by
-the value of your key. The prefix key is only applied to the primary key,
-not the master key. MEMCACHED_FAILURE will be returned if no key is set. In the case
-of a key which is too long MEMCACHED_BAD_KEY_PROVIDED will be returned.
+The value specified here will be prefixed to each of your keys. The value can not be greater then MEMCACHED_PREFIX_KEY_MAX_SIZE \- 1 and will reduce MEMCACHED_MAX_KEY by the value of your key.
+.sp
+The prefix key is only applied to the primary key, not the master key. MEMCACHED_FAILURE will be returned if no key is set. In the case of a key which is too long, MEMCACHED_BAD_KEY_PROVIDED will be returned.
.sp
If you set a value with the value being NULL then the prefix key is disabled.
-.UNINDENT
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_USER_DATA
-.
+.UNINDENT
+.sp
This allows you to store a pointer to a specifc piece of data. This can be
retrieved from inside of memcached_fetch_execute(). Cloning a memcached_st
will copy the pointer to the clone.
-.UNINDENT
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_MALLOC_FUNCTION
-.
-DEPRECATED: use memcached_set_memory_allocators instead.
.UNINDENT
+.sp
+DEPRECATED: use memcached_set_memory_allocators instead.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_REALLOC_FUNCTION
-.
-DEPRECATED: use memcached_set_memory_allocators instead.
.UNINDENT
+.sp
+DEPRECATED: use memcached_set_memory_allocators instead.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_FREE_FUNCTION
-.
-DEPRECATED: use memcached_set_memory_allocators instead.
.UNINDENT
+.sp
+DEPRECATED: use memcached_set_memory_allocators instead.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_GET_FAILURE
-.
+.UNINDENT
+.sp
This function implements the read through cache behavior. On failure of retrieval this callback will be called.
-You are responsible for populating the result object provided. This result object will then be stored in the server and
-returned to the calling process. You must clone the memcached_st in order to
+.sp
+You are responsible for populating the result object provided. This result object will then be stored in the server and returned to the calling process.
+.sp
+You must clone the memcached_st in order to
make use of it. The value will be stored only if you return
MEMCACHED_SUCCESS or MEMCACHED_BUFFERED. Returning MEMCACHED_BUFFERED will
cause the object to be buffered and not sent immediatly (if this is the default behavior based on your connection setup this will happen automatically).
.sp
The prototype for this is:
memcached_return_t (*memcached_trigger_key)(memcached_st *ptr, char *key, size_t key_length, memcached_result_st *result);
-.UNINDENT
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_DELETE_TRIGGER
-.TH "MEMCACHED_CALLBACK_GET" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_CALLBACK_GET" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_callback_get \- libmemcached Documentation
.
.
.sp
Get and set a callback
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.TP
.B void * memcached_callback_get (memcached_st *ptr, memcached_callback_t flag, memcached_return_t *error);
.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) can have callbacks set key execution points. These either
memcached_callback_set() changes the function/structure assigned by a
callback flag. No connections are reset.
.sp
-You can use MEMCACHED_CALLBACK_USER_DATA to provide custom context if required for any
-of the callbacks
+You can use MEMCACHED_CALLBACK_USER_DATA to provide custom context if required for any of the callbacks.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_CLEANUP_FUNCTION
-.
-When memcached_delete() is called this function will be excuted. At the
-point of its execution all connections have been closed.
.UNINDENT
+.sp
+When memcached_delete() is called this function will be excuted. At the point of its execution all connections are closed.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_CLONE_FUNCTION
-.
-When memcached_delete() is called this function will be excuted. At the
-point of its execution all connections have been closed.
.UNINDENT
+.sp
+When memcached_delete() is called this function will be excuted. At the
+point of its execution all connections are closed.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_PREFIX_KEY
-.
+.UNINDENT
+.sp
You can set a value which will be used to create a domain for your keys.
-The value specified here will be prefixed to each of your keys. The value can not
-be greater then MEMCACHED_PREFIX_KEY_MAX_SIZE \- 1 and will reduce MEMCACHED_MAX_KEY by
-the value of your key. The prefix key is only applied to the primary key,
-not the master key. MEMCACHED_FAILURE will be returned if no key is set. In the case
-of a key which is too long MEMCACHED_BAD_KEY_PROVIDED will be returned.
+The value specified here will be prefixed to each of your keys. The value can not be greater then MEMCACHED_PREFIX_KEY_MAX_SIZE \- 1 and will reduce MEMCACHED_MAX_KEY by the value of your key.
+.sp
+The prefix key is only applied to the primary key, not the master key. MEMCACHED_FAILURE will be returned if no key is set. In the case of a key which is too long, MEMCACHED_BAD_KEY_PROVIDED will be returned.
.sp
If you set a value with the value being NULL then the prefix key is disabled.
-.UNINDENT
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_USER_DATA
-.
+.UNINDENT
+.sp
This allows you to store a pointer to a specifc piece of data. This can be
retrieved from inside of memcached_fetch_execute(). Cloning a memcached_st
will copy the pointer to the clone.
-.UNINDENT
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_MALLOC_FUNCTION
-.
-DEPRECATED: use memcached_set_memory_allocators instead.
.UNINDENT
+.sp
+DEPRECATED: use memcached_set_memory_allocators instead.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_REALLOC_FUNCTION
-.
-DEPRECATED: use memcached_set_memory_allocators instead.
.UNINDENT
+.sp
+DEPRECATED: use memcached_set_memory_allocators instead.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_FREE_FUNCTION
-.
-DEPRECATED: use memcached_set_memory_allocators instead.
.UNINDENT
+.sp
+DEPRECATED: use memcached_set_memory_allocators instead.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_GET_FAILURE
-.
+.UNINDENT
+.sp
This function implements the read through cache behavior. On failure of retrieval this callback will be called.
-You are responsible for populating the result object provided. This result object will then be stored in the server and
-returned to the calling process. You must clone the memcached_st in order to
+.sp
+You are responsible for populating the result object provided. This result object will then be stored in the server and returned to the calling process.
+.sp
+You must clone the memcached_st in order to
make use of it. The value will be stored only if you return
MEMCACHED_SUCCESS or MEMCACHED_BUFFERED. Returning MEMCACHED_BUFFERED will
cause the object to be buffered and not sent immediatly (if this is the default behavior based on your connection setup this will happen automatically).
.sp
The prototype for this is:
memcached_return_t (*memcached_trigger_key)(memcached_st *ptr, char *key, size_t key_length, memcached_result_st *result);
-.UNINDENT
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_DELETE_TRIGGER
-.TH "MEMCACHED_CALLBACK_SET" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_CALLBACK_SET" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_callback_set \- libmemcached Documentation
.
.
.sp
Get and set a callback
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.TP
.B void * memcached_callback_get (memcached_st *ptr, memcached_callback_t flag, memcached_return_t *error);
.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) can have callbacks set key execution points. These either
memcached_callback_set() changes the function/structure assigned by a
callback flag. No connections are reset.
.sp
-You can use MEMCACHED_CALLBACK_USER_DATA to provide custom context if required for any
-of the callbacks
+You can use MEMCACHED_CALLBACK_USER_DATA to provide custom context if required for any of the callbacks.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_CLEANUP_FUNCTION
-.
-When memcached_delete() is called this function will be excuted. At the
-point of its execution all connections have been closed.
.UNINDENT
+.sp
+When memcached_delete() is called this function will be excuted. At the point of its execution all connections are closed.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_CLONE_FUNCTION
-.
-When memcached_delete() is called this function will be excuted. At the
-point of its execution all connections have been closed.
.UNINDENT
+.sp
+When memcached_delete() is called this function will be excuted. At the
+point of its execution all connections are closed.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_PREFIX_KEY
-.
+.UNINDENT
+.sp
You can set a value which will be used to create a domain for your keys.
-The value specified here will be prefixed to each of your keys. The value can not
-be greater then MEMCACHED_PREFIX_KEY_MAX_SIZE \- 1 and will reduce MEMCACHED_MAX_KEY by
-the value of your key. The prefix key is only applied to the primary key,
-not the master key. MEMCACHED_FAILURE will be returned if no key is set. In the case
-of a key which is too long MEMCACHED_BAD_KEY_PROVIDED will be returned.
+The value specified here will be prefixed to each of your keys. The value can not be greater then MEMCACHED_PREFIX_KEY_MAX_SIZE \- 1 and will reduce MEMCACHED_MAX_KEY by the value of your key.
+.sp
+The prefix key is only applied to the primary key, not the master key. MEMCACHED_FAILURE will be returned if no key is set. In the case of a key which is too long, MEMCACHED_BAD_KEY_PROVIDED will be returned.
.sp
If you set a value with the value being NULL then the prefix key is disabled.
-.UNINDENT
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_USER_DATA
-.
+.UNINDENT
+.sp
This allows you to store a pointer to a specifc piece of data. This can be
retrieved from inside of memcached_fetch_execute(). Cloning a memcached_st
will copy the pointer to the clone.
-.UNINDENT
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_MALLOC_FUNCTION
-.
-DEPRECATED: use memcached_set_memory_allocators instead.
.UNINDENT
+.sp
+DEPRECATED: use memcached_set_memory_allocators instead.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_REALLOC_FUNCTION
-.
-DEPRECATED: use memcached_set_memory_allocators instead.
.UNINDENT
+.sp
+DEPRECATED: use memcached_set_memory_allocators instead.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_FREE_FUNCTION
-.
-DEPRECATED: use memcached_set_memory_allocators instead.
.UNINDENT
+.sp
+DEPRECATED: use memcached_set_memory_allocators instead.
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_GET_FAILURE
-.
+.UNINDENT
+.sp
This function implements the read through cache behavior. On failure of retrieval this callback will be called.
-You are responsible for populating the result object provided. This result object will then be stored in the server and
-returned to the calling process. You must clone the memcached_st in order to
+.sp
+You are responsible for populating the result object provided. This result object will then be stored in the server and returned to the calling process.
+.sp
+You must clone the memcached_st in order to
make use of it. The value will be stored only if you return
MEMCACHED_SUCCESS or MEMCACHED_BUFFERED. Returning MEMCACHED_BUFFERED will
cause the object to be buffered and not sent immediatly (if this is the default behavior based on your connection setup this will happen automatically).
.sp
The prototype for this is:
memcached_return_t (*memcached_trigger_key)(memcached_st *ptr, char *key, size_t key_length, memcached_result_st *result);
-.UNINDENT
.INDENT 0.0
.TP
.B MEMCACHED_CALLBACK_DELETE_TRIGGER
-.TH "MEMCACHED_CAS" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_CAS" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
-memcached_cas \- Storing and Replacing Data
+memcached_cas \- Working with data on the server in an atomic fashion
.
.nr rst2man-indent-level 0
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Store value on server
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.INDENT 0.0
.TP
-.B memcached_return_t memcached_set (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_add (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_replace (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_prepend(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_cas(memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
.UNINDENT
.INDENT 0.0
.TP
-.B memcached_return_t memcached_set_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_add_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_replace_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_prepend_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_cas_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
.UNINDENT
.sp
Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
-memcached_set(), memcached_add(), and memcached_replace() are all used to
-store information on the server. All methods take a key, and its length to
-store the object. Keys are currently limited to 250 characters by the
-memcached(1) server. You must also supply a value and a length. Optionally you
-may tests an expiration time for the object and a 16 byte value (it is
-meant to be used as a bitmap).
-.sp
-memcached_set() will write an object to the server. If an object already
-exists it will overwrite what is in the server. If the object does not exist
-it will be written. If you are using the non\-blocking mode this function
-will always return true unless a network error occurs.
-.sp
-memcached_replace() replaces an object on the server. If the object is not
-found on the server an error occurs.
-.sp
-memcached_add() adds an object to the server. If the object is found on the
-server an error occurs, otherwise the value is stored.
-.sp
-memcached_prepend() places a segment of data before the last piece of data
-stored. Currently expiration and key are not used in the server.
-.sp
-memcached_append() places a segment of data at the end of the last piece of
-data stored. Currently expiration and key are not used in the server.
-.sp
memcached_cas() overwrites data in the server as long as the "cas" value is
still the same in the server. You can get the cas value of a result by
calling memcached_result_cas() on a memcached_result_st(3) structure. At the point
for it in libmemcached(3) is optional. Please see memcached_set() for
information on how to do this.
.sp
-memcached_set_by_key(), memcached_add_by_key(), memcached_replace_by_key(),
-memcached_prepend_by_key(), memcached_append_by_key_by_key(),
-memcached_cas_by_key() methods all behave in a similar method as the non key
-methods. The difference is that they use their group_key parameter to map
+memcached_cas_by_key() method behaves in a similar method as the non key
+methods. The difference is that it uses the group_key parameter to map
objects to particular servers.
.sp
-If you are looking for performance, memcached_set() with non\-blocking IO is
-the fastest way to store data on the server.
-.sp
-All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. But when using these operations with this behavior on, there
+memcached_cas() is testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. However, when using these operations with this behavior on, there
are limits to the size of the payload being sent to the server. The reason for
-these limits is that the Memcahed Server does not allow multi\-datagram requests
+these limits is that the Memcached Server does not allow multi\-datagram requests
and the current server implementation sets a datagram size to 1400 bytes. Due
to protocol overhead, the actual limit of the user supplied data is less than
-1400 bytes and depends on the protocol in use as well as the operation being
+1400 bytes and depends on the protocol in use as, well as the operation being
executed. When running with the binary protocol, \(ga\(ga MEMCACHED_BEHAVIOR_BINARY_PROTOCOL\(ga\(ga,
the size of the key,value, flags and expiry combined may not exceed 1368 bytes.
When running with the ASCII protocol, the exact limit fluctuates depending on
All methods return a value of type \fBmemcached_return_t\fP.
On success the value will be \fBMEMCACHED_SUCCESS\fP.
Use memcached_strerror() to translate this value to a printable string.
-.sp
-For memcached_replace() and memcached_add(), \fBMEMCACHED_NOTSTORED\fP is a
-legitmate error in the case of a collision.
.SH HOME
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
.SH SEE ALSO
.sp
-memcached(1) libmemached(3) memcached_strerror(3)
+memcached(1) libmemached(3) memcached_strerror(3) memcached_set(3) memcached_append(3) memcached_add(3) memcached_prepend(3) memcached_replace(3)
.SH AUTHOR
Brian Aker
.SH COPYRIGHT
-.TH "MEMCACHED_CAS_BY_KEY" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_CAS_BY_KEY" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_cas_by_key \- Storing and Replacing Data
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Store value on server
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.INDENT 0.0
.TP
-.B memcached_return_t memcached_set (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_add (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_replace (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_prepend(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_cas(memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
.UNINDENT
.INDENT 0.0
.TP
-.B memcached_return_t memcached_set_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_add_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_replace_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_prepend_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_cas_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
.UNINDENT
.sp
Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
-memcached_set(), memcached_add(), and memcached_replace() are all used to
-store information on the server. All methods take a key, and its length to
-store the object. Keys are currently limited to 250 characters by the
-memcached(1) server. You must also supply a value and a length. Optionally you
-may tests an expiration time for the object and a 16 byte value (it is
-meant to be used as a bitmap).
-.sp
-memcached_set() will write an object to the server. If an object already
-exists it will overwrite what is in the server. If the object does not exist
-it will be written. If you are using the non\-blocking mode this function
-will always return true unless a network error occurs.
-.sp
-memcached_replace() replaces an object on the server. If the object is not
-found on the server an error occurs.
-.sp
-memcached_add() adds an object to the server. If the object is found on the
-server an error occurs, otherwise the value is stored.
-.sp
-memcached_prepend() places a segment of data before the last piece of data
-stored. Currently expiration and key are not used in the server.
-.sp
-memcached_append() places a segment of data at the end of the last piece of
-data stored. Currently expiration and key are not used in the server.
-.sp
memcached_cas() overwrites data in the server as long as the "cas" value is
still the same in the server. You can get the cas value of a result by
calling memcached_result_cas() on a memcached_result_st(3) structure. At the point
for it in libmemcached(3) is optional. Please see memcached_set() for
information on how to do this.
.sp
-memcached_set_by_key(), memcached_add_by_key(), memcached_replace_by_key(),
-memcached_prepend_by_key(), memcached_append_by_key_by_key(),
-memcached_cas_by_key() methods all behave in a similar method as the non key
-methods. The difference is that they use their group_key parameter to map
+memcached_cas_by_key() method behaves in a similar method as the non key
+methods. The difference is that it uses the group_key parameter to map
objects to particular servers.
.sp
-If you are looking for performance, memcached_set() with non\-blocking IO is
-the fastest way to store data on the server.
-.sp
-All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. But when using these operations with this behavior on, there
+memcached_cas() is testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. However, when using these operations with this behavior on, there
are limits to the size of the payload being sent to the server. The reason for
-these limits is that the Memcahed Server does not allow multi\-datagram requests
+these limits is that the Memcached Server does not allow multi\-datagram requests
and the current server implementation sets a datagram size to 1400 bytes. Due
to protocol overhead, the actual limit of the user supplied data is less than
-1400 bytes and depends on the protocol in use as well as the operation being
+1400 bytes and depends on the protocol in use as, well as the operation being
executed. When running with the binary protocol, \(ga\(ga MEMCACHED_BEHAVIOR_BINARY_PROTOCOL\(ga\(ga,
the size of the key,value, flags and expiry combined may not exceed 1368 bytes.
When running with the ASCII protocol, the exact limit fluctuates depending on
All methods return a value of type \fBmemcached_return_t\fP.
On success the value will be \fBMEMCACHED_SUCCESS\fP.
Use memcached_strerror() to translate this value to a printable string.
-.sp
-For memcached_replace() and memcached_add(), \fBMEMCACHED_NOTSTORED\fP is a
-legitmate error in the case of a collision.
.SH HOME
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
.SH SEE ALSO
.sp
-memcached(1) libmemached(3) memcached_strerror(3)
+memcached(1) libmemached(3) memcached_strerror(3) memcached_set(3) memcached_append(3) memcached_add(3) memcached_prepend(3) memcached_replace(3)
.SH AUTHOR
Brian Aker
.SH COPYRIGHT
-.TH "MEMCACHED_CLONE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_CLONE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_clone \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Create a memcached_st structure
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
-.TH "MEMCACHED_CREATE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_CREATE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_create \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Create a memcached_st structure
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
-.TH "MEMCACHED_DECREMENT" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_DECREMENT" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_decrement \- Incrementing and Decrementing Values
.
-.TH "MEMCACHED_DECREMENT_WITH_INITIAL" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_DECREMENT_WITH_INITIAL" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_decrement_with_initial \- Incrementing and Decrementing Values
.
-.TH "MEMCACHED_DELETE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_DELETE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_delete \- libmemcached Documentation
.
find the given value.
.sp
Expiration works by placing the item into a delete queue, which means that
-it won\(aqt possible to retrieve it by the "get" command, but "add" and
-"replace" command with this key will also fail (the "set" command will
+it won\(aqt be possible to retrieve it by the "get" command. The "add" and
+"replace" commands with this key will also fail (the "set" command will
succeed, however). After the time passes, the item is finally deleted from server memory.
.sp
Please note the the Danga memcached server removed tests for expiration in
-.TH "MEMCACHED_DELETE_BY_KEY" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_DELETE_BY_KEY" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_delete_by_key \- libmemcached Documentation
.
find the given value.
.sp
Expiration works by placing the item into a delete queue, which means that
-it won\(aqt possible to retrieve it by the "get" command, but "add" and
-"replace" command with this key will also fail (the "set" command will
+it won\(aqt be possible to retrieve it by the "get" command. The "add" and
+"replace" commands with this key will also fail (the "set" command will
succeed, however). After the time passes, the item is finally deleted from server memory.
.sp
Please note the the Danga memcached server removed tests for expiration in
-.TH "MEMCACHED_DESTROY_SASL_AUTH_DATA" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_DESTROY_SASL_AUTH_DATA" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_destroy_sasl_auth_data \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/memcached.h>
-
-void memcached_set_sasl_callbacks(memcached_st *ptr,
- const sasl_callback_t *callbacks)
-
-const sasl_callback_t *memcached_get_sasl_callbacks(memcached_st *ptr)
-
-memcached_return memcached_set_sasl_auth_data(memcached_st *ptr,
- const char *username,
- const char *password)
-memcached_return memcached_destroy_sasl_auth_data(memcached_st *ptr)
-.ft P
-.fi
+#include <libmemcached/memcached_pool.h>
+.INDENT 0.0
+.TP
+.B void memcached_set_sasl_callbacks(memcached_st\fI\ *ptr\fP, const sasl_callback_t\fI\ *callbacks\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const sasl_callback_t *memcached_get_sasl_callbacks(memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return memcached_set_sasl_auth_data(memcached_st\fI\ *ptr\fP, const char\fI\ *username\fP, const char\fI\ *password\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return memcached_destroy_sasl_auth_data(memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) allows you to plug in your own callbacks function used by
Please note that SASL requires the memcached binary protocol, and you have
to specify the callbacks before you connect to the server.
.sp
-memcached_set_sasl_auth_data() is a helper function for you defining
+memcached_set_sasl_auth_data() is a helper function defining
the basic functionality for you, but it will store the username and password
in memory. If you choose to use this method you have to call
memcached_destroy_sasl_auth_data before calling memcached_free to avoid
-.TH "MEMCACHED_DUMP" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_DUMP" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_dump \- libmemcached Documentation
.
.
.sp
Get a list of keys found on memcached servers
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-memcached_return_t
- memcached_dump (memcached_st *ptr,
- memcached_dump_fn *function,
- void *context,
- uint32_t number_of_callbacks);
-
-typedef memcached_return_t (*memcached_dump_fn)(memcached_st *ptr,
- const char *key,
- size_t key_length,
- void *context);
-.ft P
-.fi
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_dump (memcached_st *ptr, memcached_dump_fn *function, void *context, uint32_t number_of_callbacks);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B typedef memcached_return_t (*memcached_dump_fn)(memcached_st *ptr, const char *key, size_t key_length, void *context);
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
-memcached_dump() is used to get a list of keys found memcached(1) servers.
+memcached_dump() is used to get a list of keys found in memcached(1) servers.
Because memcached(1) does not guarentee to dump all keys you can not assume
you have fetched all keys from the server. The function takes an array
of callbacks that it will use to execute on keys as they are found.
.sp
-Currently the binar protocol is not testsed.
+Currently the binary protocol is not testsed.
.SH RETURN
.sp
A value of type \fBmemcached_return_t\fP is returned
-.TH "MEMCACHED_FETCH" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_FETCH" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_fetch \- Retrieving data from the server
.
upon success and NULL will be returned on failure. MEMCACHD_END is returned
by the *error value when all objects that have been found are returned.
The final value upon MEMCACHED_END is null. Values returned by
-memcached_fetch() musted be free\(aqed by the caller. memcached_fetch() will
+memcached_fetch() must be freed by the caller. memcached_fetch() will
be DEPRECATED in the near future, memcached_fetch_result() should be used
instead.
.sp
similar to memcached_mget(), but it may trigger the supplied callbacks
with result sets while sending out the queries. If you try to perform
a really large multiget with memcached_mget() you may encounter a
-deadlock in the OS kernel (we fail to write data to the socket because
+deadlock in the OS kernel (it will fail to write data to the socket because
the input buffer is full). memcached_mget_execute() solves this
problem by processing some of the results before continuing sending
out requests. Please note that this function is only available in the
a master key that is used for determining which server an object was stored
if key partitioning was used for storage.
.sp
-All of the above functions are not testsed when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
-\fBMEMCACHED_NOT_SUPPORTED\fP being returned or, for those functions which do not return
+All of the above functions are not tested when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
+\fBMEMCACHED_NOT_SUPPORTED\fP being returned, or for those functions which do not return
a \fBmemcached_return_t\fP, the error function parameter will be set to
\fBMEMCACHED_NOT_SUPPORTED\fP.
.SH RETURN
-.TH "MEMCACHED_FETCH_EXECUTE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_FETCH_EXECUTE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_fetch_execute \- Retrieving data from the server
.
upon success and NULL will be returned on failure. MEMCACHD_END is returned
by the *error value when all objects that have been found are returned.
The final value upon MEMCACHED_END is null. Values returned by
-memcached_fetch() musted be free\(aqed by the caller. memcached_fetch() will
+memcached_fetch() must be freed by the caller. memcached_fetch() will
be DEPRECATED in the near future, memcached_fetch_result() should be used
instead.
.sp
similar to memcached_mget(), but it may trigger the supplied callbacks
with result sets while sending out the queries. If you try to perform
a really large multiget with memcached_mget() you may encounter a
-deadlock in the OS kernel (we fail to write data to the socket because
+deadlock in the OS kernel (it will fail to write data to the socket because
the input buffer is full). memcached_mget_execute() solves this
problem by processing some of the results before continuing sending
out requests. Please note that this function is only available in the
a master key that is used for determining which server an object was stored
if key partitioning was used for storage.
.sp
-All of the above functions are not testsed when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
-\fBMEMCACHED_NOT_SUPPORTED\fP being returned or, for those functions which do not return
+All of the above functions are not tested when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
+\fBMEMCACHED_NOT_SUPPORTED\fP being returned, or for those functions which do not return
a \fBmemcached_return_t\fP, the error function parameter will be set to
\fBMEMCACHED_NOT_SUPPORTED\fP.
.SH RETURN
-.TH "MEMCACHED_FETCH_RESULT" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_FETCH_RESULT" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_fetch_result \- Retrieving data from the server
.
upon success and NULL will be returned on failure. MEMCACHD_END is returned
by the *error value when all objects that have been found are returned.
The final value upon MEMCACHED_END is null. Values returned by
-memcached_fetch() musted be free\(aqed by the caller. memcached_fetch() will
+memcached_fetch() must be freed by the caller. memcached_fetch() will
be DEPRECATED in the near future, memcached_fetch_result() should be used
instead.
.sp
similar to memcached_mget(), but it may trigger the supplied callbacks
with result sets while sending out the queries. If you try to perform
a really large multiget with memcached_mget() you may encounter a
-deadlock in the OS kernel (we fail to write data to the socket because
+deadlock in the OS kernel (it will fail to write data to the socket because
the input buffer is full). memcached_mget_execute() solves this
problem by processing some of the results before continuing sending
out requests. Please note that this function is only available in the
a master key that is used for determining which server an object was stored
if key partitioning was used for storage.
.sp
-All of the above functions are not testsed when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
-\fBMEMCACHED_NOT_SUPPORTED\fP being returned or, for those functions which do not return
+All of the above functions are not tested when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
+\fBMEMCACHED_NOT_SUPPORTED\fP being returned, or for those functions which do not return
a \fBmemcached_return_t\fP, the error function parameter will be set to
\fBMEMCACHED_NOT_SUPPORTED\fP.
.SH RETURN
-.TH "MEMCACHED_FLUSH" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_FLUSH" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_flush \- libmemcached Documentation
.
-.TH "MEMCACHED_FLUSH_BUFFERS" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_FLUSH_BUFFERS" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_flush_buffers \- libmemcached Documentation
.
.\" Man page generated from reStructeredText.
.
.sp
-Flush buffers and send buffered commands
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
+Flush and senf buffered commands
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.TP
.B memcached_return_t memcached_flush_buffers (memcached_st *ptr);
.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
memcached_flush_buffers() is used in conjunction with
-.TH "MEMCACHED_FREE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_FREE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_free \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Create a memcached_st structure
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
-.TH "MEMCACHED_GENERATE_HASH" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_GENERATE_HASH" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_generate_hash \- Generating hash values directly
.
-.TH "MEMCACHED_GENERATE_HASH_VALUE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_GENERATE_HASH_VALUE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_generate_hash_value \- Generating hash values directly
.
-.TH "MEMCACHED_GET" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_GET" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_get \- Retrieving data from the server
.
upon success and NULL will be returned on failure. MEMCACHD_END is returned
by the *error value when all objects that have been found are returned.
The final value upon MEMCACHED_END is null. Values returned by
-memcached_fetch() musted be free\(aqed by the caller. memcached_fetch() will
+memcached_fetch() must be freed by the caller. memcached_fetch() will
be DEPRECATED in the near future, memcached_fetch_result() should be used
instead.
.sp
similar to memcached_mget(), but it may trigger the supplied callbacks
with result sets while sending out the queries. If you try to perform
a really large multiget with memcached_mget() you may encounter a
-deadlock in the OS kernel (we fail to write data to the socket because
+deadlock in the OS kernel (it will fail to write data to the socket because
the input buffer is full). memcached_mget_execute() solves this
problem by processing some of the results before continuing sending
out requests. Please note that this function is only available in the
a master key that is used for determining which server an object was stored
if key partitioning was used for storage.
.sp
-All of the above functions are not testsed when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
-\fBMEMCACHED_NOT_SUPPORTED\fP being returned or, for those functions which do not return
+All of the above functions are not tested when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
+\fBMEMCACHED_NOT_SUPPORTED\fP being returned, or for those functions which do not return
a \fBmemcached_return_t\fP, the error function parameter will be set to
\fBMEMCACHED_NOT_SUPPORTED\fP.
.SH RETURN
-.TH "MEMCACHED_GET_BY_KEY" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_GET_BY_KEY" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_get_by_key \- Retrieving data from the server
.
upon success and NULL will be returned on failure. MEMCACHD_END is returned
by the *error value when all objects that have been found are returned.
The final value upon MEMCACHED_END is null. Values returned by
-memcached_fetch() musted be free\(aqed by the caller. memcached_fetch() will
+memcached_fetch() must be freed by the caller. memcached_fetch() will
be DEPRECATED in the near future, memcached_fetch_result() should be used
instead.
.sp
similar to memcached_mget(), but it may trigger the supplied callbacks
with result sets while sending out the queries. If you try to perform
a really large multiget with memcached_mget() you may encounter a
-deadlock in the OS kernel (we fail to write data to the socket because
+deadlock in the OS kernel (it will fail to write data to the socket because
the input buffer is full). memcached_mget_execute() solves this
problem by processing some of the results before continuing sending
out requests. Please note that this function is only available in the
a master key that is used for determining which server an object was stored
if key partitioning was used for storage.
.sp
-All of the above functions are not testsed when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
-\fBMEMCACHED_NOT_SUPPORTED\fP being returned or, for those functions which do not return
+All of the above functions are not tested when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
+\fBMEMCACHED_NOT_SUPPORTED\fP being returned, or for those functions which do not return
a \fBmemcached_return_t\fP, the error function parameter will be set to
\fBMEMCACHED_NOT_SUPPORTED\fP.
.SH RETURN
-.TH "MEMCACHED_GET_MEMORY_ALLOCATORS" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_GET_MEMORY_ALLOCATORS" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_get_memory_allocators \- libmemcached Documentation
.
.
.sp
Manage memory allocator functions
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-memcached_return_t memcached_set_memory_allocators (memcached_st *ptr, memcached_malloc_fn mem_malloc, memcached_free_fn mem_free, memcached_realloc_fn mem_realloc, memcached_calloc_fn mem_calloc, void *context);
-
-void memcached_get_memory_allocators (memcached_st *ptr, memcached_malloc_fn *mem_malloc, memcached_free_fn *mem_free, memcached_realloc_fn *mem_realloc, memcached_calloc_fn *mem_calloc);
-
-void * memcached_get_memory_allocators_context(const memcached_st *ptr);
-
-void * (*memcached_malloc_fn) (memcached_st *ptr, const size_t size, void *context);
-
-void * (*memcached_realloc_fn) (memcached_st *ptr, void *mem, const size_t size, void *context);
-
-void (*memcached_free_fn) (memcached_st *ptr, void *mem, void *context);
-
-void * (*memcached_calloc_fn) (memcached_st *ptr, size_t nelem, const size_t elsize, void *context);
-.ft P
-.fi
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_set_memory_allocators (memcached_st *ptr, memcached_malloc_fn mem_malloc, memcached_free_fn mem_free, memcached_realloc_fn mem_realloc, memcached_calloc_fn mem_calloc, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_get_memory_allocators (memcached_st *ptr, memcached_malloc_fn *mem_malloc, memcached_free_fn *mem_free, memcached_realloc_fn *mem_realloc, memcached_calloc_fn *mem_calloc);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * memcached_get_memory_allocators_context(const memcached_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * (*memcached_malloc_fn) (memcached_st *ptr, const size_t size, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * (*memcached_realloc_fn) (memcached_st *ptr, void *mem, const size_t size, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void (*memcached_free_fn) (memcached_st *ptr, void *mem, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * (*memcached_calloc_fn) (memcached_st *ptr, size_t nelem, const size_t elsize, void *context);
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
-libmemcached(3) allows you to specify your own memory allocators optimized
+libmemcached(3) allows you to specify your own memory allocators, optimized
for your application. This enables libmemcached to be used inside of applications that have their own malloc implementation.
.sp
memcached_set_memory_allocators() is used to set the memory allocators used
-.TH "MEMCACHED_GET_SASL_CALLBACKS" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_GET_SASL_CALLBACKS" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_get_sasl_callbacks \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/memcached.h>
-
-void memcached_set_sasl_callbacks(memcached_st *ptr,
- const sasl_callback_t *callbacks)
-
-const sasl_callback_t *memcached_get_sasl_callbacks(memcached_st *ptr)
-
-memcached_return memcached_set_sasl_auth_data(memcached_st *ptr,
- const char *username,
- const char *password)
-memcached_return memcached_destroy_sasl_auth_data(memcached_st *ptr)
-.ft P
-.fi
+#include <libmemcached/memcached_pool.h>
+.INDENT 0.0
+.TP
+.B void memcached_set_sasl_callbacks(memcached_st\fI\ *ptr\fP, const sasl_callback_t\fI\ *callbacks\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const sasl_callback_t *memcached_get_sasl_callbacks(memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return memcached_set_sasl_auth_data(memcached_st\fI\ *ptr\fP, const char\fI\ *username\fP, const char\fI\ *password\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return memcached_destroy_sasl_auth_data(memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) allows you to plug in your own callbacks function used by
Please note that SASL requires the memcached binary protocol, and you have
to specify the callbacks before you connect to the server.
.sp
-memcached_set_sasl_auth_data() is a helper function for you defining
+memcached_set_sasl_auth_data() is a helper function defining
the basic functionality for you, but it will store the username and password
in memory. If you choose to use this method you have to call
memcached_destroy_sasl_auth_data before calling memcached_free to avoid
-.TH "MEMCACHED_GET_USER_DATA" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_GET_USER_DATA" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_get_user_data \- libmemcached Documentation
.
.SH LIBRARY
.sp
C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
+.SH SYNOPSIS
.sp
.nf
.ft C
void *memcached_set_user_data (memcached_st *ptr, void *data);
.ft P
.fi
-.SS DESCRIPTION
+.SH DESCRIPTION
.sp
libmemcached(3) allows you to store a pointer to a user specific data inside
the memcached_st structure.
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
-.SH AUTHOR
-.sp
-Trond Norbye, <\fI\%trond.norbye@gmail.com\fP>
-.SS SEE ALSO
+.SH SEE ALSO
.sp
memcached(1) libmemcached(3)
.SH AUTHOR
-.TH "MEMCACHED_INCREMENT" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_INCREMENT" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_increment \- Incrementing and Decrementing Values
.
-.TH "MEMCACHED_INCREMENT_WITH_INITIAL" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_INCREMENT_WITH_INITIAL" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_increment_with_initial \- Incrementing and Decrementing Values
.
-.TH "MEMCACHED_LIB_VERSION" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_LIB_VERSION" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_lib_version \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
+.SH SYNOPSIS
.sp
-Get library version
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-const char *
- memcached_lib_version (void)
-
-
-memcached_return_t
- memcached_version (memcached_st *ptr)
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B const char * memcached_lib_version(void)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_version(memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
memcached_lib_version() is used to return a simple version string representing
-the libmemcached version (version of the client library, not server)
+the libmemcached version (client library version, not server version)
.sp
memcached_version() is used to set the major, minor, and micro versions of each
memcached server being used by the memcached_st connection structure. It returns the
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
-.SH AUTHOR
-.sp
-Brian Aker, <\fI\%brian@tangent.org\fP>
-.SS SEE ALSO
+.SH SEE ALSO
.sp
memcached(1) libmemcached(3) memcached_strerror(3)
.SH AUTHOR
-.TH "MEMCACHED_MEMORY_ALLOCATORS" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_MEMORY_ALLOCATORS" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_memory_allocators \- libmemcached Documentation
.
.
.sp
Manage memory allocator functions
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-memcached_return_t memcached_set_memory_allocators (memcached_st *ptr, memcached_malloc_fn mem_malloc, memcached_free_fn mem_free, memcached_realloc_fn mem_realloc, memcached_calloc_fn mem_calloc, void *context);
-
-void memcached_get_memory_allocators (memcached_st *ptr, memcached_malloc_fn *mem_malloc, memcached_free_fn *mem_free, memcached_realloc_fn *mem_realloc, memcached_calloc_fn *mem_calloc);
-
-void * memcached_get_memory_allocators_context(const memcached_st *ptr);
-
-void * (*memcached_malloc_fn) (memcached_st *ptr, const size_t size, void *context);
-
-void * (*memcached_realloc_fn) (memcached_st *ptr, void *mem, const size_t size, void *context);
-
-void (*memcached_free_fn) (memcached_st *ptr, void *mem, void *context);
-
-void * (*memcached_calloc_fn) (memcached_st *ptr, size_t nelem, const size_t elsize, void *context);
-.ft P
-.fi
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_set_memory_allocators (memcached_st *ptr, memcached_malloc_fn mem_malloc, memcached_free_fn mem_free, memcached_realloc_fn mem_realloc, memcached_calloc_fn mem_calloc, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_get_memory_allocators (memcached_st *ptr, memcached_malloc_fn *mem_malloc, memcached_free_fn *mem_free, memcached_realloc_fn *mem_realloc, memcached_calloc_fn *mem_calloc);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * memcached_get_memory_allocators_context(const memcached_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * (*memcached_malloc_fn) (memcached_st *ptr, const size_t size, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * (*memcached_realloc_fn) (memcached_st *ptr, void *mem, const size_t size, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void (*memcached_free_fn) (memcached_st *ptr, void *mem, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * (*memcached_calloc_fn) (memcached_st *ptr, size_t nelem, const size_t elsize, void *context);
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
-libmemcached(3) allows you to specify your own memory allocators optimized
+libmemcached(3) allows you to specify your own memory allocators, optimized
for your application. This enables libmemcached to be used inside of applications that have their own malloc implementation.
.sp
memcached_set_memory_allocators() is used to set the memory allocators used
-.TH "MEMCACHED_MGET" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_MGET" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_mget \- Retrieving data from the server
.
upon success and NULL will be returned on failure. MEMCACHD_END is returned
by the *error value when all objects that have been found are returned.
The final value upon MEMCACHED_END is null. Values returned by
-memcached_fetch() musted be free\(aqed by the caller. memcached_fetch() will
+memcached_fetch() must be freed by the caller. memcached_fetch() will
be DEPRECATED in the near future, memcached_fetch_result() should be used
instead.
.sp
similar to memcached_mget(), but it may trigger the supplied callbacks
with result sets while sending out the queries. If you try to perform
a really large multiget with memcached_mget() you may encounter a
-deadlock in the OS kernel (we fail to write data to the socket because
+deadlock in the OS kernel (it will fail to write data to the socket because
the input buffer is full). memcached_mget_execute() solves this
problem by processing some of the results before continuing sending
out requests. Please note that this function is only available in the
a master key that is used for determining which server an object was stored
if key partitioning was used for storage.
.sp
-All of the above functions are not testsed when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
-\fBMEMCACHED_NOT_SUPPORTED\fP being returned or, for those functions which do not return
+All of the above functions are not tested when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
+\fBMEMCACHED_NOT_SUPPORTED\fP being returned, or for those functions which do not return
a \fBmemcached_return_t\fP, the error function parameter will be set to
\fBMEMCACHED_NOT_SUPPORTED\fP.
.SH RETURN
-.TH "MEMCACHED_MGET_BY_KEY" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_MGET_BY_KEY" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_mget_by_key \- Retrieving data from the server
.
upon success and NULL will be returned on failure. MEMCACHD_END is returned
by the *error value when all objects that have been found are returned.
The final value upon MEMCACHED_END is null. Values returned by
-memcached_fetch() musted be free\(aqed by the caller. memcached_fetch() will
+memcached_fetch() must be freed by the caller. memcached_fetch() will
be DEPRECATED in the near future, memcached_fetch_result() should be used
instead.
.sp
similar to memcached_mget(), but it may trigger the supplied callbacks
with result sets while sending out the queries. If you try to perform
a really large multiget with memcached_mget() you may encounter a
-deadlock in the OS kernel (we fail to write data to the socket because
+deadlock in the OS kernel (it will fail to write data to the socket because
the input buffer is full). memcached_mget_execute() solves this
problem by processing some of the results before continuing sending
out requests. Please note that this function is only available in the
a master key that is used for determining which server an object was stored
if key partitioning was used for storage.
.sp
-All of the above functions are not testsed when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
-\fBMEMCACHED_NOT_SUPPORTED\fP being returned or, for those functions which do not return
+All of the above functions are not tested when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
+\fBMEMCACHED_NOT_SUPPORTED\fP being returned, or for those functions which do not return
a \fBmemcached_return_t\fP, the error function parameter will be set to
\fBMEMCACHED_NOT_SUPPORTED\fP.
.SH RETURN
-.TH "MEMCACHED_MGET_EXECUTE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_MGET_EXECUTE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_mget_execute \- Retrieving data from the server
.
upon success and NULL will be returned on failure. MEMCACHD_END is returned
by the *error value when all objects that have been found are returned.
The final value upon MEMCACHED_END is null. Values returned by
-memcached_fetch() musted be free\(aqed by the caller. memcached_fetch() will
+memcached_fetch() must be freed by the caller. memcached_fetch() will
be DEPRECATED in the near future, memcached_fetch_result() should be used
instead.
.sp
similar to memcached_mget(), but it may trigger the supplied callbacks
with result sets while sending out the queries. If you try to perform
a really large multiget with memcached_mget() you may encounter a
-deadlock in the OS kernel (we fail to write data to the socket because
+deadlock in the OS kernel (it will fail to write data to the socket because
the input buffer is full). memcached_mget_execute() solves this
problem by processing some of the results before continuing sending
out requests. Please note that this function is only available in the
a master key that is used for determining which server an object was stored
if key partitioning was used for storage.
.sp
-All of the above functions are not testsed when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
-\fBMEMCACHED_NOT_SUPPORTED\fP being returned or, for those functions which do not return
+All of the above functions are not tested when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
+\fBMEMCACHED_NOT_SUPPORTED\fP being returned, or for those functions which do not return
a \fBmemcached_return_t\fP, the error function parameter will be set to
\fBMEMCACHED_NOT_SUPPORTED\fP.
.SH RETURN
-.TH "MEMCACHED_MGET_EXECUTE_BY_KEY" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_MGET_EXECUTE_BY_KEY" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_mget_execute_by_key \- Retrieving data from the server
.
upon success and NULL will be returned on failure. MEMCACHD_END is returned
by the *error value when all objects that have been found are returned.
The final value upon MEMCACHED_END is null. Values returned by
-memcached_fetch() musted be free\(aqed by the caller. memcached_fetch() will
+memcached_fetch() must be freed by the caller. memcached_fetch() will
be DEPRECATED in the near future, memcached_fetch_result() should be used
instead.
.sp
similar to memcached_mget(), but it may trigger the supplied callbacks
with result sets while sending out the queries. If you try to perform
a really large multiget with memcached_mget() you may encounter a
-deadlock in the OS kernel (we fail to write data to the socket because
+deadlock in the OS kernel (it will fail to write data to the socket because
the input buffer is full). memcached_mget_execute() solves this
problem by processing some of the results before continuing sending
out requests. Please note that this function is only available in the
a master key that is used for determining which server an object was stored
if key partitioning was used for storage.
.sp
-All of the above functions are not testsed when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
-\fBMEMCACHED_NOT_SUPPORTED\fP being returned or, for those functions which do not return
+All of the above functions are not tested when the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPhas been set. Executing any of these functions with this behavior on will result in
+\fBMEMCACHED_NOT_SUPPORTED\fP being returned, or for those functions which do not return
a \fBmemcached_return_t\fP, the error function parameter will be set to
\fBMEMCACHED_NOT_SUPPORTED\fP.
.SH RETURN
-.TH "MEMCACHED_POOL" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_POOL" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_pool \- libmemcached Documentation
.
-.TH "MEMCACHED_POOL_BEHAVIOR_GET" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_POOL_BEHAVIOR_GET" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_pool_behavior_get \- libmemcached Documentation
.
-.TH "MEMCACHED_POOL_BEHAVIOR_SET" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_POOL_BEHAVIOR_SET" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_pool_behavior_set \- libmemcached Documentation
.
-.TH "MEMCACHED_POOL_CREATE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_POOL_CREATE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_pool_create \- libmemcached Documentation
.
-.TH "MEMCACHED_POOL_DESTROY" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_POOL_DESTROY" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_pool_destroy \- libmemcached Documentation
.
-.TH "MEMCACHED_POOL_POP" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_POOL_POP" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_pool_pop \- libmemcached Documentation
.
-.TH "MEMCACHED_POOL_PUSH" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_POOL_PUSH" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_pool_push \- libmemcached Documentation
.
-.TH "MEMCACHED_POOL_ST" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_POOL_ST" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_pool_st \- libmemcached Documentation
.
-.TH "MEMCACHED_PREPEND" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_PREPEND" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
-memcached_prepend \- Storing and Replacing Data
+memcached_prepend \- Appending to or Prepending to data on the server
.
.nr rst2man-indent-level 0
.
.\" Man page generated from reStructeredText.
.
.sp
-Store value on server
+Appending or Prepending to data on the server
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.INDENT 0.0
.TP
-.B memcached_return_t memcached_set (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_add (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_replace (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_prepend(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
.UNINDENT
.INDENT 0.0
.UNINDENT
.INDENT 0.0
.TP
-.B memcached_return_t memcached_cas(memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_set_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_add_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_replace_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_prepend_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
.INDENT 0.0
.TP
.B memcached_return_t memcached_append_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
.sp
Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
-memcached_set(), memcached_add(), and memcached_replace() are all used to
-store information on the server. All methods take a key, and its length to
-store the object. Keys are currently limited to 250 characters by the
-memcached(1) server. You must also supply a value and a length. Optionally you
-may tests an expiration time for the object and a 16 byte value (it is
-meant to be used as a bitmap).
-.sp
-memcached_set() will write an object to the server. If an object already
-exists it will overwrite what is in the server. If the object does not exist
-it will be written. If you are using the non\-blocking mode this function
-will always return true unless a network error occurs.
-.sp
-memcached_replace() replaces an object on the server. If the object is not
-found on the server an error occurs.
-.sp
-memcached_add() adds an object to the server. If the object is found on the
-server an error occurs, otherwise the value is stored.
+memcached_prepend() and memcached_append are used to
+modify information on a server. All methods take a key, and its length to
+store the object. Keys are currently limited to 250 characters when using either a version of memcached(1) which is 1.4 or below, or when using the text protocol.
+You must supply both a value and a length. Optionally you
+may test an expiration time for the object and a 16 byte value (it is
+meant to be used as a bitmap). "flags" is a 4byte space that is stored alongside of the main value. Many sub libraries make use of this field, so in most cases users should avoid making use of it.
.sp
memcached_prepend() places a segment of data before the last piece of data
stored. Currently expiration and key are not used in the server.
memcached_append() places a segment of data at the end of the last piece of
data stored. Currently expiration and key are not used in the server.
.sp
-memcached_cas() overwrites data in the server as long as the "cas" value is
-still the same in the server. You can get the cas value of a result by
-calling memcached_result_cas() on a memcached_result_st(3) structure. At the point
-that this note was written cas is still buggy in memached. Turning on tests
-for it in libmemcached(3) is optional. Please see memcached_set() for
-information on how to do this.
-.sp
-memcached_set_by_key(), memcached_add_by_key(), memcached_replace_by_key(),
-memcached_prepend_by_key(), memcached_append_by_key_by_key(),
-memcached_cas_by_key() methods all behave in a similar method as the non key
+memcached_prepend_by_key() and memcached_append_by_key_by_key(,
+methods both behave in a similar method as the non key
methods. The difference is that they use their group_key parameter to map
objects to particular servers.
.sp
If you are looking for performance, memcached_set() with non\-blocking IO is
the fastest way to store data on the server.
.sp
-All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. But when using these operations with this behavior on, there
+All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. However, when using these operations with this behavior on, there
are limits to the size of the payload being sent to the server. The reason for
-these limits is that the Memcahed Server does not allow multi\-datagram requests
+these limits is that the Memcached Server does not allow multi\-datagram requests
and the current server implementation sets a datagram size to 1400 bytes. Due
to protocol overhead, the actual limit of the user supplied data is less than
-1400 bytes and depends on the protocol in use as well as the operation being
+1400 bytes and depends on the protocol in use as, well as the operation being
executed. When running with the binary protocol, \(ga\(ga MEMCACHED_BEHAVIOR_BINARY_PROTOCOL\(ga\(ga,
the size of the key,value, flags and expiry combined may not exceed 1368 bytes.
When running with the ASCII protocol, the exact limit fluctuates depending on
All methods return a value of type \fBmemcached_return_t\fP.
On success the value will be \fBMEMCACHED_SUCCESS\fP.
Use memcached_strerror() to translate this value to a printable string.
-.sp
-For memcached_replace() and memcached_add(), \fBMEMCACHED_NOTSTORED\fP is a
-legitmate error in the case of a collision.
.SH HOME
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
.SH SEE ALSO
.sp
-memcached(1) libmemached(3) memcached_strerror(3)
+memcached(1) libmemached(3) memcached_strerror(3) memcached_set(3) memcached_add(3) memcached_cas(3) memcached_replace(3)
.SH AUTHOR
Brian Aker
.SH COPYRIGHT
-.TH "MEMCACHED_PREPEND_BY_KEY" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_PREPEND_BY_KEY" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
-memcached_prepend_by_key \- Storing and Replacing Data
+memcached_prepend_by_key \- Appending to or Prepending to data on the server
.
.nr rst2man-indent-level 0
.
.\" Man page generated from reStructeredText.
.
.sp
-Store value on server
+Appending or Prepending to data on the server
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.INDENT 0.0
.TP
-.B memcached_return_t memcached_set (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_add (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_replace (memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_prepend(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
.UNINDENT
.INDENT 0.0
.UNINDENT
.INDENT 0.0
.TP
-.B memcached_return_t memcached_cas(memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_set_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_add_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_replace_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_prepend_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
.INDENT 0.0
.TP
.B memcached_return_t memcached_append_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
.sp
Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
-memcached_set(), memcached_add(), and memcached_replace() are all used to
-store information on the server. All methods take a key, and its length to
-store the object. Keys are currently limited to 250 characters by the
-memcached(1) server. You must also supply a value and a length. Optionally you
-may tests an expiration time for the object and a 16 byte value (it is
-meant to be used as a bitmap).
-.sp
-memcached_set() will write an object to the server. If an object already
-exists it will overwrite what is in the server. If the object does not exist
-it will be written. If you are using the non\-blocking mode this function
-will always return true unless a network error occurs.
-.sp
-memcached_replace() replaces an object on the server. If the object is not
-found on the server an error occurs.
-.sp
-memcached_add() adds an object to the server. If the object is found on the
-server an error occurs, otherwise the value is stored.
+memcached_prepend() and memcached_append are used to
+modify information on a server. All methods take a key, and its length to
+store the object. Keys are currently limited to 250 characters when using either a version of memcached(1) which is 1.4 or below, or when using the text protocol.
+You must supply both a value and a length. Optionally you
+may test an expiration time for the object and a 16 byte value (it is
+meant to be used as a bitmap). "flags" is a 4byte space that is stored alongside of the main value. Many sub libraries make use of this field, so in most cases users should avoid making use of it.
.sp
memcached_prepend() places a segment of data before the last piece of data
stored. Currently expiration and key are not used in the server.
memcached_append() places a segment of data at the end of the last piece of
data stored. Currently expiration and key are not used in the server.
.sp
-memcached_cas() overwrites data in the server as long as the "cas" value is
-still the same in the server. You can get the cas value of a result by
-calling memcached_result_cas() on a memcached_result_st(3) structure. At the point
-that this note was written cas is still buggy in memached. Turning on tests
-for it in libmemcached(3) is optional. Please see memcached_set() for
-information on how to do this.
-.sp
-memcached_set_by_key(), memcached_add_by_key(), memcached_replace_by_key(),
-memcached_prepend_by_key(), memcached_append_by_key_by_key(),
-memcached_cas_by_key() methods all behave in a similar method as the non key
+memcached_prepend_by_key() and memcached_append_by_key_by_key(,
+methods both behave in a similar method as the non key
methods. The difference is that they use their group_key parameter to map
objects to particular servers.
.sp
If you are looking for performance, memcached_set() with non\-blocking IO is
the fastest way to store data on the server.
.sp
-All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. But when using these operations with this behavior on, there
+All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. However, when using these operations with this behavior on, there
are limits to the size of the payload being sent to the server. The reason for
-these limits is that the Memcahed Server does not allow multi\-datagram requests
+these limits is that the Memcached Server does not allow multi\-datagram requests
and the current server implementation sets a datagram size to 1400 bytes. Due
to protocol overhead, the actual limit of the user supplied data is less than
-1400 bytes and depends on the protocol in use as well as the operation being
+1400 bytes and depends on the protocol in use as, well as the operation being
executed. When running with the binary protocol, \(ga\(ga MEMCACHED_BEHAVIOR_BINARY_PROTOCOL\(ga\(ga,
the size of the key,value, flags and expiry combined may not exceed 1368 bytes.
When running with the ASCII protocol, the exact limit fluctuates depending on
All methods return a value of type \fBmemcached_return_t\fP.
On success the value will be \fBMEMCACHED_SUCCESS\fP.
Use memcached_strerror() to translate this value to a printable string.
-.sp
-For memcached_replace() and memcached_add(), \fBMEMCACHED_NOTSTORED\fP is a
-legitmate error in the case of a collision.
.SH HOME
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
.SH SEE ALSO
.sp
-memcached(1) libmemached(3) memcached_strerror(3)
+memcached(1) libmemached(3) memcached_strerror(3) memcached_set(3) memcached_add(3) memcached_cas(3) memcached_replace(3)
.SH AUTHOR
Brian Aker
.SH COPYRIGHT
-.TH "MEMCACHED_QUIT" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_QUIT" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_quit \- libmemcached Documentation
.
-.TH "MEMCACHED_REPLACE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_REPLACE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_replace \- Storing and Replacing Data
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Store value on server
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.UNINDENT
.INDENT 0.0
.TP
-.B memcached_return_t memcached_prepend(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas(memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_set_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
.INDENT 0.0
.TP
.B memcached_return_t memcached_replace_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_prepend_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
.sp
Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
memcached_set(), memcached_add(), and memcached_replace() are all used to
store information on the server. All methods take a key, and its length to
-store the object. Keys are currently limited to 250 characters by the
-memcached(1) server. You must also supply a value and a length. Optionally you
-may tests an expiration time for the object and a 16 byte value (it is
-meant to be used as a bitmap).
+store the object. Keys are currently limited to 250 characters when using either a version of memcached(1) which is 1.4 or below, or when using the text protocol.
+You must supply both a value and a length. Optionally you
+may test an expiration time for the object and a 16 byte value (it is
+meant to be used as a bitmap). "flags" is a 4byte space that is stored alongside of the main value. Many sub libraries make use of this field, so in most cases users should avoid making use of it.
.sp
memcached_set() will write an object to the server. If an object already
exists it will overwrite what is in the server. If the object does not exist
memcached_add() adds an object to the server. If the object is found on the
server an error occurs, otherwise the value is stored.
.sp
-memcached_prepend() places a segment of data before the last piece of data
-stored. Currently expiration and key are not used in the server.
-.sp
-memcached_append() places a segment of data at the end of the last piece of
-data stored. Currently expiration and key are not used in the server.
-.sp
memcached_cas() overwrites data in the server as long as the "cas" value is
still the same in the server. You can get the cas value of a result by
calling memcached_result_cas() on a memcached_result_st(3) structure. At the point
for it in libmemcached(3) is optional. Please see memcached_set() for
information on how to do this.
.sp
-memcached_set_by_key(), memcached_add_by_key(), memcached_replace_by_key(),
-memcached_prepend_by_key(), memcached_append_by_key_by_key(),
-memcached_cas_by_key() methods all behave in a similar method as the non key
+memcached_set_by_key(), memcached_add_by_key(), and memcached_replace_by_key()
+methods all behave in a similar method as the non key
methods. The difference is that they use their group_key parameter to map
objects to particular servers.
.sp
If you are looking for performance, memcached_set() with non\-blocking IO is
the fastest way to store data on the server.
.sp
-All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. But when using these operations with this behavior on, there
+All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. However, when using these operations with this behavior on, there
are limits to the size of the payload being sent to the server. The reason for
-these limits is that the Memcahed Server does not allow multi\-datagram requests
+these limits is that the Memcached Server does not allow multi\-datagram requests
and the current server implementation sets a datagram size to 1400 bytes. Due
to protocol overhead, the actual limit of the user supplied data is less than
-1400 bytes and depends on the protocol in use as well as the operation being
+1400 bytes and depends on the protocol in use as, well as the operation being
executed. When running with the binary protocol, \(ga\(ga MEMCACHED_BEHAVIOR_BINARY_PROTOCOL\(ga\(ga,
the size of the key,value, flags and expiry combined may not exceed 1368 bytes.
When running with the ASCII protocol, the exact limit fluctuates depending on
\fI\%http://libmemcached.org/\fP
.SH SEE ALSO
.sp
-memcached(1) libmemached(3) memcached_strerror(3)
+memcached(1) libmemached(3) memcached_strerror(3) memcached_prepend(3) memcached_cas(3) memcached_append(3)
.SH AUTHOR
Brian Aker
.SH COPYRIGHT
-.TH "MEMCACHED_REPLACE_BY_KEY" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_REPLACE_BY_KEY" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_replace_by_key \- Storing and Replacing Data
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Store value on server
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.UNINDENT
.INDENT 0.0
.TP
-.B memcached_return_t memcached_prepend(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas(memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_set_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
.INDENT 0.0
.TP
.B memcached_return_t memcached_replace_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_prepend_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
.sp
Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
memcached_set(), memcached_add(), and memcached_replace() are all used to
store information on the server. All methods take a key, and its length to
-store the object. Keys are currently limited to 250 characters by the
-memcached(1) server. You must also supply a value and a length. Optionally you
-may tests an expiration time for the object and a 16 byte value (it is
-meant to be used as a bitmap).
+store the object. Keys are currently limited to 250 characters when using either a version of memcached(1) which is 1.4 or below, or when using the text protocol.
+You must supply both a value and a length. Optionally you
+may test an expiration time for the object and a 16 byte value (it is
+meant to be used as a bitmap). "flags" is a 4byte space that is stored alongside of the main value. Many sub libraries make use of this field, so in most cases users should avoid making use of it.
.sp
memcached_set() will write an object to the server. If an object already
exists it will overwrite what is in the server. If the object does not exist
memcached_add() adds an object to the server. If the object is found on the
server an error occurs, otherwise the value is stored.
.sp
-memcached_prepend() places a segment of data before the last piece of data
-stored. Currently expiration and key are not used in the server.
-.sp
-memcached_append() places a segment of data at the end of the last piece of
-data stored. Currently expiration and key are not used in the server.
-.sp
memcached_cas() overwrites data in the server as long as the "cas" value is
still the same in the server. You can get the cas value of a result by
calling memcached_result_cas() on a memcached_result_st(3) structure. At the point
for it in libmemcached(3) is optional. Please see memcached_set() for
information on how to do this.
.sp
-memcached_set_by_key(), memcached_add_by_key(), memcached_replace_by_key(),
-memcached_prepend_by_key(), memcached_append_by_key_by_key(),
-memcached_cas_by_key() methods all behave in a similar method as the non key
+memcached_set_by_key(), memcached_add_by_key(), and memcached_replace_by_key()
+methods all behave in a similar method as the non key
methods. The difference is that they use their group_key parameter to map
objects to particular servers.
.sp
If you are looking for performance, memcached_set() with non\-blocking IO is
the fastest way to store data on the server.
.sp
-All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. But when using these operations with this behavior on, there
+All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. However, when using these operations with this behavior on, there
are limits to the size of the payload being sent to the server. The reason for
-these limits is that the Memcahed Server does not allow multi\-datagram requests
+these limits is that the Memcached Server does not allow multi\-datagram requests
and the current server implementation sets a datagram size to 1400 bytes. Due
to protocol overhead, the actual limit of the user supplied data is less than
-1400 bytes and depends on the protocol in use as well as the operation being
+1400 bytes and depends on the protocol in use as, well as the operation being
executed. When running with the binary protocol, \(ga\(ga MEMCACHED_BEHAVIOR_BINARY_PROTOCOL\(ga\(ga,
the size of the key,value, flags and expiry combined may not exceed 1368 bytes.
When running with the ASCII protocol, the exact limit fluctuates depending on
\fI\%http://libmemcached.org/\fP
.SH SEE ALSO
.sp
-memcached(1) libmemached(3) memcached_strerror(3)
+memcached(1) libmemached(3) memcached_strerror(3) memcached_prepend(3) memcached_cas(3) memcached_append(3)
.SH AUTHOR
Brian Aker
.SH COPYRIGHT
-.TH "MEMCACHED_RESULT_CAS" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_RESULT_CAS" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_result_cas \- Working with result sets
.
.
.sp
Work with memcached_result_st
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/memcached.h>
-
-memcached_result_st *
- memcached_result_create (memcached_st *ptr,
- memcached_result_st *result);
-
-void memcached_result_free (memcached_result_st *result);
-
-const char * memcached_result_key_value (memcached_result_st *result);
-
-size_t memcached_result_key_length (const memcached_result_st *result);
-
-const char *memcached_result_value (memcached_result_st *ptr);
-
-size_t memcached_result_length (const memcached_result_st *ptr);
-
-uint32_t memcached_result_flags (const memcached_result_st *result)
-
-uint64_t memcached_result_cas (const memcached_result_st *result);
-
-memcached_return_t
- memcached_result_set_value (memcached_result_st *ptr,
- const char *value, size_t length)
-
-void memcached_result_set_flags (memcached_result_st *ptr, uint32_t flags)
-
-void memcached_result_set_expiration (memcached_result_st *ptr, time_t)
-.ft P
-.fi
+#include <libmemcached/memcached_pool.h>
+.INDENT 0.0
+.TP
+.B memcached_result_st * memcached_result_create (memcached_st *ptr, memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_free (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char * memcached_result_key_value (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_key_length (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char *memcached_result_value (memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_length (const memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t memcached_result_flags(const memcached_result_st\fI\ *result\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint64_t memcached_result_cas (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_result_set_value(memcached_result_st\fI\ *ptr\fP, const char\fI\ *value\fP, size_t\fI\ length\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_flags(memcached_result_st\fI\ *ptr\fP, uint32_t\fI\ flags\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_expiration(memcached_result_st\fI\ *ptr\fP, time_t)
+.UNINDENT
+.sp
+Compile and link with \-lmemcachedutil \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) can optionally return a memcached_result_st which acts as a
result object. The result objects have added benefits over the character
-pointer returns in that they are forward compatible with new return items
+pointer returns, in that they are forward compatible with new return items
that future memcached servers may implement (the best current example of
-this is the CAS return item). The structures can also be reused which will
+this is the CAS return item). The structures can also be reused, which will
save on calls to malloc(3). It is suggested that you use result objects over
char * return functions.
.sp
memcached_result_st or will initialize a structure passed to it.
.sp
memcached_result_free() will deallocate any memory attached to the
-structure. If the structure was also alloacted, it will deallocate it.
+structure. If the structure was also allocated, it will deallocate it.
.sp
memcached_result_key_value() returns the key value associated with the
current result object.
.sp
memcached_result_cas() returns the cas associated with the
current result object. This value will only be available if the server
-testss it.
+tests it.
.sp
memcached_result_set_value() takes a byte array and a size and sets
the result to this value. This function is used for trigger responses.
-.TH "MEMCACHED_RESULT_CREATE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_RESULT_CREATE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_result_create \- Working with result sets
.
.
.sp
Work with memcached_result_st
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/memcached.h>
-
-memcached_result_st *
- memcached_result_create (memcached_st *ptr,
- memcached_result_st *result);
-
-void memcached_result_free (memcached_result_st *result);
-
-const char * memcached_result_key_value (memcached_result_st *result);
-
-size_t memcached_result_key_length (const memcached_result_st *result);
-
-const char *memcached_result_value (memcached_result_st *ptr);
-
-size_t memcached_result_length (const memcached_result_st *ptr);
-
-uint32_t memcached_result_flags (const memcached_result_st *result)
-
-uint64_t memcached_result_cas (const memcached_result_st *result);
-
-memcached_return_t
- memcached_result_set_value (memcached_result_st *ptr,
- const char *value, size_t length)
-
-void memcached_result_set_flags (memcached_result_st *ptr, uint32_t flags)
-
-void memcached_result_set_expiration (memcached_result_st *ptr, time_t)
-.ft P
-.fi
+#include <libmemcached/memcached_pool.h>
+.INDENT 0.0
+.TP
+.B memcached_result_st * memcached_result_create (memcached_st *ptr, memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_free (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char * memcached_result_key_value (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_key_length (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char *memcached_result_value (memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_length (const memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t memcached_result_flags(const memcached_result_st\fI\ *result\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint64_t memcached_result_cas (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_result_set_value(memcached_result_st\fI\ *ptr\fP, const char\fI\ *value\fP, size_t\fI\ length\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_flags(memcached_result_st\fI\ *ptr\fP, uint32_t\fI\ flags\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_expiration(memcached_result_st\fI\ *ptr\fP, time_t)
+.UNINDENT
+.sp
+Compile and link with \-lmemcachedutil \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) can optionally return a memcached_result_st which acts as a
result object. The result objects have added benefits over the character
-pointer returns in that they are forward compatible with new return items
+pointer returns, in that they are forward compatible with new return items
that future memcached servers may implement (the best current example of
-this is the CAS return item). The structures can also be reused which will
+this is the CAS return item). The structures can also be reused, which will
save on calls to malloc(3). It is suggested that you use result objects over
char * return functions.
.sp
memcached_result_st or will initialize a structure passed to it.
.sp
memcached_result_free() will deallocate any memory attached to the
-structure. If the structure was also alloacted, it will deallocate it.
+structure. If the structure was also allocated, it will deallocate it.
.sp
memcached_result_key_value() returns the key value associated with the
current result object.
.sp
memcached_result_cas() returns the cas associated with the
current result object. This value will only be available if the server
-testss it.
+tests it.
.sp
memcached_result_set_value() takes a byte array and a size and sets
the result to this value. This function is used for trigger responses.
-.TH "MEMCACHED_RESULT_FLAGS" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_RESULT_FLAGS" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_result_flags \- Working with result sets
.
.
.sp
Work with memcached_result_st
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/memcached.h>
-
-memcached_result_st *
- memcached_result_create (memcached_st *ptr,
- memcached_result_st *result);
-
-void memcached_result_free (memcached_result_st *result);
-
-const char * memcached_result_key_value (memcached_result_st *result);
-
-size_t memcached_result_key_length (const memcached_result_st *result);
-
-const char *memcached_result_value (memcached_result_st *ptr);
-
-size_t memcached_result_length (const memcached_result_st *ptr);
-
-uint32_t memcached_result_flags (const memcached_result_st *result)
-
-uint64_t memcached_result_cas (const memcached_result_st *result);
-
-memcached_return_t
- memcached_result_set_value (memcached_result_st *ptr,
- const char *value, size_t length)
-
-void memcached_result_set_flags (memcached_result_st *ptr, uint32_t flags)
-
-void memcached_result_set_expiration (memcached_result_st *ptr, time_t)
-.ft P
-.fi
+#include <libmemcached/memcached_pool.h>
+.INDENT 0.0
+.TP
+.B memcached_result_st * memcached_result_create (memcached_st *ptr, memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_free (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char * memcached_result_key_value (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_key_length (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char *memcached_result_value (memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_length (const memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t memcached_result_flags(const memcached_result_st\fI\ *result\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint64_t memcached_result_cas (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_result_set_value(memcached_result_st\fI\ *ptr\fP, const char\fI\ *value\fP, size_t\fI\ length\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_flags(memcached_result_st\fI\ *ptr\fP, uint32_t\fI\ flags\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_expiration(memcached_result_st\fI\ *ptr\fP, time_t)
+.UNINDENT
+.sp
+Compile and link with \-lmemcachedutil \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) can optionally return a memcached_result_st which acts as a
result object. The result objects have added benefits over the character
-pointer returns in that they are forward compatible with new return items
+pointer returns, in that they are forward compatible with new return items
that future memcached servers may implement (the best current example of
-this is the CAS return item). The structures can also be reused which will
+this is the CAS return item). The structures can also be reused, which will
save on calls to malloc(3). It is suggested that you use result objects over
char * return functions.
.sp
memcached_result_st or will initialize a structure passed to it.
.sp
memcached_result_free() will deallocate any memory attached to the
-structure. If the structure was also alloacted, it will deallocate it.
+structure. If the structure was also allocated, it will deallocate it.
.sp
memcached_result_key_value() returns the key value associated with the
current result object.
.sp
memcached_result_cas() returns the cas associated with the
current result object. This value will only be available if the server
-testss it.
+tests it.
.sp
memcached_result_set_value() takes a byte array and a size and sets
the result to this value. This function is used for trigger responses.
-.TH "MEMCACHED_RESULT_FREE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_RESULT_FREE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_result_free \- Working with result sets
.
.
.sp
Work with memcached_result_st
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/memcached.h>
-
-memcached_result_st *
- memcached_result_create (memcached_st *ptr,
- memcached_result_st *result);
-
-void memcached_result_free (memcached_result_st *result);
-
-const char * memcached_result_key_value (memcached_result_st *result);
-
-size_t memcached_result_key_length (const memcached_result_st *result);
-
-const char *memcached_result_value (memcached_result_st *ptr);
-
-size_t memcached_result_length (const memcached_result_st *ptr);
-
-uint32_t memcached_result_flags (const memcached_result_st *result)
-
-uint64_t memcached_result_cas (const memcached_result_st *result);
-
-memcached_return_t
- memcached_result_set_value (memcached_result_st *ptr,
- const char *value, size_t length)
-
-void memcached_result_set_flags (memcached_result_st *ptr, uint32_t flags)
-
-void memcached_result_set_expiration (memcached_result_st *ptr, time_t)
-.ft P
-.fi
+#include <libmemcached/memcached_pool.h>
+.INDENT 0.0
+.TP
+.B memcached_result_st * memcached_result_create (memcached_st *ptr, memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_free (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char * memcached_result_key_value (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_key_length (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char *memcached_result_value (memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_length (const memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t memcached_result_flags(const memcached_result_st\fI\ *result\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint64_t memcached_result_cas (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_result_set_value(memcached_result_st\fI\ *ptr\fP, const char\fI\ *value\fP, size_t\fI\ length\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_flags(memcached_result_st\fI\ *ptr\fP, uint32_t\fI\ flags\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_expiration(memcached_result_st\fI\ *ptr\fP, time_t)
+.UNINDENT
+.sp
+Compile and link with \-lmemcachedutil \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) can optionally return a memcached_result_st which acts as a
result object. The result objects have added benefits over the character
-pointer returns in that they are forward compatible with new return items
+pointer returns, in that they are forward compatible with new return items
that future memcached servers may implement (the best current example of
-this is the CAS return item). The structures can also be reused which will
+this is the CAS return item). The structures can also be reused, which will
save on calls to malloc(3). It is suggested that you use result objects over
char * return functions.
.sp
memcached_result_st or will initialize a structure passed to it.
.sp
memcached_result_free() will deallocate any memory attached to the
-structure. If the structure was also alloacted, it will deallocate it.
+structure. If the structure was also allocated, it will deallocate it.
.sp
memcached_result_key_value() returns the key value associated with the
current result object.
.sp
memcached_result_cas() returns the cas associated with the
current result object. This value will only be available if the server
-testss it.
+tests it.
.sp
memcached_result_set_value() takes a byte array and a size and sets
the result to this value. This function is used for trigger responses.
-.TH "MEMCACHED_RESULT_KEY_LENGTH" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_RESULT_KEY_LENGTH" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_result_key_length \- Working with result sets
.
.
.sp
Work with memcached_result_st
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/memcached.h>
-
-memcached_result_st *
- memcached_result_create (memcached_st *ptr,
- memcached_result_st *result);
-
-void memcached_result_free (memcached_result_st *result);
-
-const char * memcached_result_key_value (memcached_result_st *result);
-
-size_t memcached_result_key_length (const memcached_result_st *result);
-
-const char *memcached_result_value (memcached_result_st *ptr);
-
-size_t memcached_result_length (const memcached_result_st *ptr);
-
-uint32_t memcached_result_flags (const memcached_result_st *result)
-
-uint64_t memcached_result_cas (const memcached_result_st *result);
-
-memcached_return_t
- memcached_result_set_value (memcached_result_st *ptr,
- const char *value, size_t length)
-
-void memcached_result_set_flags (memcached_result_st *ptr, uint32_t flags)
-
-void memcached_result_set_expiration (memcached_result_st *ptr, time_t)
-.ft P
-.fi
+#include <libmemcached/memcached_pool.h>
+.INDENT 0.0
+.TP
+.B memcached_result_st * memcached_result_create (memcached_st *ptr, memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_free (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char * memcached_result_key_value (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_key_length (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char *memcached_result_value (memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_length (const memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t memcached_result_flags(const memcached_result_st\fI\ *result\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint64_t memcached_result_cas (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_result_set_value(memcached_result_st\fI\ *ptr\fP, const char\fI\ *value\fP, size_t\fI\ length\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_flags(memcached_result_st\fI\ *ptr\fP, uint32_t\fI\ flags\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_expiration(memcached_result_st\fI\ *ptr\fP, time_t)
+.UNINDENT
+.sp
+Compile and link with \-lmemcachedutil \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) can optionally return a memcached_result_st which acts as a
result object. The result objects have added benefits over the character
-pointer returns in that they are forward compatible with new return items
+pointer returns, in that they are forward compatible with new return items
that future memcached servers may implement (the best current example of
-this is the CAS return item). The structures can also be reused which will
+this is the CAS return item). The structures can also be reused, which will
save on calls to malloc(3). It is suggested that you use result objects over
char * return functions.
.sp
memcached_result_st or will initialize a structure passed to it.
.sp
memcached_result_free() will deallocate any memory attached to the
-structure. If the structure was also alloacted, it will deallocate it.
+structure. If the structure was also allocated, it will deallocate it.
.sp
memcached_result_key_value() returns the key value associated with the
current result object.
.sp
memcached_result_cas() returns the cas associated with the
current result object. This value will only be available if the server
-testss it.
+tests it.
.sp
memcached_result_set_value() takes a byte array and a size and sets
the result to this value. This function is used for trigger responses.
-.TH "MEMCACHED_RESULT_KEY_VALUE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_RESULT_KEY_VALUE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_result_key_value \- Working with result sets
.
.
.sp
Work with memcached_result_st
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/memcached.h>
-
-memcached_result_st *
- memcached_result_create (memcached_st *ptr,
- memcached_result_st *result);
-
-void memcached_result_free (memcached_result_st *result);
-
-const char * memcached_result_key_value (memcached_result_st *result);
-
-size_t memcached_result_key_length (const memcached_result_st *result);
-
-const char *memcached_result_value (memcached_result_st *ptr);
-
-size_t memcached_result_length (const memcached_result_st *ptr);
-
-uint32_t memcached_result_flags (const memcached_result_st *result)
-
-uint64_t memcached_result_cas (const memcached_result_st *result);
-
-memcached_return_t
- memcached_result_set_value (memcached_result_st *ptr,
- const char *value, size_t length)
-
-void memcached_result_set_flags (memcached_result_st *ptr, uint32_t flags)
-
-void memcached_result_set_expiration (memcached_result_st *ptr, time_t)
-.ft P
-.fi
+#include <libmemcached/memcached_pool.h>
+.INDENT 0.0
+.TP
+.B memcached_result_st * memcached_result_create (memcached_st *ptr, memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_free (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char * memcached_result_key_value (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_key_length (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char *memcached_result_value (memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_length (const memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t memcached_result_flags(const memcached_result_st\fI\ *result\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint64_t memcached_result_cas (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_result_set_value(memcached_result_st\fI\ *ptr\fP, const char\fI\ *value\fP, size_t\fI\ length\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_flags(memcached_result_st\fI\ *ptr\fP, uint32_t\fI\ flags\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_expiration(memcached_result_st\fI\ *ptr\fP, time_t)
+.UNINDENT
+.sp
+Compile and link with \-lmemcachedutil \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) can optionally return a memcached_result_st which acts as a
result object. The result objects have added benefits over the character
-pointer returns in that they are forward compatible with new return items
+pointer returns, in that they are forward compatible with new return items
that future memcached servers may implement (the best current example of
-this is the CAS return item). The structures can also be reused which will
+this is the CAS return item). The structures can also be reused, which will
save on calls to malloc(3). It is suggested that you use result objects over
char * return functions.
.sp
memcached_result_st or will initialize a structure passed to it.
.sp
memcached_result_free() will deallocate any memory attached to the
-structure. If the structure was also alloacted, it will deallocate it.
+structure. If the structure was also allocated, it will deallocate it.
.sp
memcached_result_key_value() returns the key value associated with the
current result object.
.sp
memcached_result_cas() returns the cas associated with the
current result object. This value will only be available if the server
-testss it.
+tests it.
.sp
memcached_result_set_value() takes a byte array and a size and sets
the result to this value. This function is used for trigger responses.
-.TH "MEMCACHED_RESULT_LENGTH" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_RESULT_LENGTH" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_result_length \- Working with result sets
.
.
.sp
Work with memcached_result_st
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/memcached.h>
-
-memcached_result_st *
- memcached_result_create (memcached_st *ptr,
- memcached_result_st *result);
-
-void memcached_result_free (memcached_result_st *result);
-
-const char * memcached_result_key_value (memcached_result_st *result);
-
-size_t memcached_result_key_length (const memcached_result_st *result);
-
-const char *memcached_result_value (memcached_result_st *ptr);
-
-size_t memcached_result_length (const memcached_result_st *ptr);
-
-uint32_t memcached_result_flags (const memcached_result_st *result)
-
-uint64_t memcached_result_cas (const memcached_result_st *result);
-
-memcached_return_t
- memcached_result_set_value (memcached_result_st *ptr,
- const char *value, size_t length)
-
-void memcached_result_set_flags (memcached_result_st *ptr, uint32_t flags)
-
-void memcached_result_set_expiration (memcached_result_st *ptr, time_t)
-.ft P
-.fi
+#include <libmemcached/memcached_pool.h>
+.INDENT 0.0
+.TP
+.B memcached_result_st * memcached_result_create (memcached_st *ptr, memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_free (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char * memcached_result_key_value (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_key_length (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char *memcached_result_value (memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_length (const memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t memcached_result_flags(const memcached_result_st\fI\ *result\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint64_t memcached_result_cas (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_result_set_value(memcached_result_st\fI\ *ptr\fP, const char\fI\ *value\fP, size_t\fI\ length\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_flags(memcached_result_st\fI\ *ptr\fP, uint32_t\fI\ flags\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_expiration(memcached_result_st\fI\ *ptr\fP, time_t)
+.UNINDENT
+.sp
+Compile and link with \-lmemcachedutil \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) can optionally return a memcached_result_st which acts as a
result object. The result objects have added benefits over the character
-pointer returns in that they are forward compatible with new return items
+pointer returns, in that they are forward compatible with new return items
that future memcached servers may implement (the best current example of
-this is the CAS return item). The structures can also be reused which will
+this is the CAS return item). The structures can also be reused, which will
save on calls to malloc(3). It is suggested that you use result objects over
char * return functions.
.sp
memcached_result_st or will initialize a structure passed to it.
.sp
memcached_result_free() will deallocate any memory attached to the
-structure. If the structure was also alloacted, it will deallocate it.
+structure. If the structure was also allocated, it will deallocate it.
.sp
memcached_result_key_value() returns the key value associated with the
current result object.
.sp
memcached_result_cas() returns the cas associated with the
current result object. This value will only be available if the server
-testss it.
+tests it.
.sp
memcached_result_set_value() takes a byte array and a size and sets
the result to this value. This function is used for trigger responses.
-.TH "MEMCACHED_RESULT_ST" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_RESULT_ST" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_result_st \- Working with result sets
.
.
.sp
Work with memcached_result_st
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/memcached.h>
-
-memcached_result_st *
- memcached_result_create (memcached_st *ptr,
- memcached_result_st *result);
-
-void memcached_result_free (memcached_result_st *result);
-
-const char * memcached_result_key_value (memcached_result_st *result);
-
-size_t memcached_result_key_length (const memcached_result_st *result);
-
-const char *memcached_result_value (memcached_result_st *ptr);
-
-size_t memcached_result_length (const memcached_result_st *ptr);
-
-uint32_t memcached_result_flags (const memcached_result_st *result)
-
-uint64_t memcached_result_cas (const memcached_result_st *result);
-
-memcached_return_t
- memcached_result_set_value (memcached_result_st *ptr,
- const char *value, size_t length)
-
-void memcached_result_set_flags (memcached_result_st *ptr, uint32_t flags)
-
-void memcached_result_set_expiration (memcached_result_st *ptr, time_t)
-.ft P
-.fi
+#include <libmemcached/memcached_pool.h>
+.INDENT 0.0
+.TP
+.B memcached_result_st * memcached_result_create (memcached_st *ptr, memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_free (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char * memcached_result_key_value (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_key_length (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char *memcached_result_value (memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_length (const memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t memcached_result_flags(const memcached_result_st\fI\ *result\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint64_t memcached_result_cas (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_result_set_value(memcached_result_st\fI\ *ptr\fP, const char\fI\ *value\fP, size_t\fI\ length\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_flags(memcached_result_st\fI\ *ptr\fP, uint32_t\fI\ flags\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_expiration(memcached_result_st\fI\ *ptr\fP, time_t)
+.UNINDENT
+.sp
+Compile and link with \-lmemcachedutil \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) can optionally return a memcached_result_st which acts as a
result object. The result objects have added benefits over the character
-pointer returns in that they are forward compatible with new return items
+pointer returns, in that they are forward compatible with new return items
that future memcached servers may implement (the best current example of
-this is the CAS return item). The structures can also be reused which will
+this is the CAS return item). The structures can also be reused, which will
save on calls to malloc(3). It is suggested that you use result objects over
char * return functions.
.sp
memcached_result_st or will initialize a structure passed to it.
.sp
memcached_result_free() will deallocate any memory attached to the
-structure. If the structure was also alloacted, it will deallocate it.
+structure. If the structure was also allocated, it will deallocate it.
.sp
memcached_result_key_value() returns the key value associated with the
current result object.
.sp
memcached_result_cas() returns the cas associated with the
current result object. This value will only be available if the server
-testss it.
+tests it.
.sp
memcached_result_set_value() takes a byte array and a size and sets
the result to this value. This function is used for trigger responses.
-.TH "MEMCACHED_RESULT_VALUE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_RESULT_VALUE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_result_value \- Working with result sets
.
.
.sp
Work with memcached_result_st
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/memcached.h>
-
-memcached_result_st *
- memcached_result_create (memcached_st *ptr,
- memcached_result_st *result);
-
-void memcached_result_free (memcached_result_st *result);
-
-const char * memcached_result_key_value (memcached_result_st *result);
-
-size_t memcached_result_key_length (const memcached_result_st *result);
-
-const char *memcached_result_value (memcached_result_st *ptr);
-
-size_t memcached_result_length (const memcached_result_st *ptr);
-
-uint32_t memcached_result_flags (const memcached_result_st *result)
-
-uint64_t memcached_result_cas (const memcached_result_st *result);
-
-memcached_return_t
- memcached_result_set_value (memcached_result_st *ptr,
- const char *value, size_t length)
-
-void memcached_result_set_flags (memcached_result_st *ptr, uint32_t flags)
-
-void memcached_result_set_expiration (memcached_result_st *ptr, time_t)
-.ft P
-.fi
+#include <libmemcached/memcached_pool.h>
+.INDENT 0.0
+.TP
+.B memcached_result_st * memcached_result_create (memcached_st *ptr, memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_free (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char * memcached_result_key_value (memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_key_length (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const char *memcached_result_value (memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B size_t memcached_result_length (const memcached_result_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint32_t memcached_result_flags(const memcached_result_st\fI\ *result\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B uint64_t memcached_result_cas (const memcached_result_st *result);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_result_set_value(memcached_result_st\fI\ *ptr\fP, const char\fI\ *value\fP, size_t\fI\ length\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_flags(memcached_result_st\fI\ *ptr\fP, uint32_t\fI\ flags\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_result_set_expiration(memcached_result_st\fI\ *ptr\fP, time_t)
+.UNINDENT
+.sp
+Compile and link with \-lmemcachedutil \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) can optionally return a memcached_result_st which acts as a
result object. The result objects have added benefits over the character
-pointer returns in that they are forward compatible with new return items
+pointer returns, in that they are forward compatible with new return items
that future memcached servers may implement (the best current example of
-this is the CAS return item). The structures can also be reused which will
+this is the CAS return item). The structures can also be reused, which will
save on calls to malloc(3). It is suggested that you use result objects over
char * return functions.
.sp
memcached_result_st or will initialize a structure passed to it.
.sp
memcached_result_free() will deallocate any memory attached to the
-structure. If the structure was also alloacted, it will deallocate it.
+structure. If the structure was also allocated, it will deallocate it.
.sp
memcached_result_key_value() returns the key value associated with the
current result object.
.sp
memcached_result_cas() returns the cas associated with the
current result object. This value will only be available if the server
-testss it.
+tests it.
.sp
memcached_result_set_value() takes a byte array and a size and sets
the result to this value. This function is used for trigger responses.
-.TH "MEMCACHED_SASL" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SASL" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_sasl \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/memcached.h>
-
-void memcached_set_sasl_callbacks(memcached_st *ptr,
- const sasl_callback_t *callbacks)
-
-const sasl_callback_t *memcached_get_sasl_callbacks(memcached_st *ptr)
-
-memcached_return memcached_set_sasl_auth_data(memcached_st *ptr,
- const char *username,
- const char *password)
-memcached_return memcached_destroy_sasl_auth_data(memcached_st *ptr)
-.ft P
-.fi
+#include <libmemcached/memcached_pool.h>
+.INDENT 0.0
+.TP
+.B void memcached_set_sasl_callbacks(memcached_st\fI\ *ptr\fP, const sasl_callback_t\fI\ *callbacks\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const sasl_callback_t *memcached_get_sasl_callbacks(memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return memcached_set_sasl_auth_data(memcached_st\fI\ *ptr\fP, const char\fI\ *username\fP, const char\fI\ *password\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return memcached_destroy_sasl_auth_data(memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) allows you to plug in your own callbacks function used by
Please note that SASL requires the memcached binary protocol, and you have
to specify the callbacks before you connect to the server.
.sp
-memcached_set_sasl_auth_data() is a helper function for you defining
+memcached_set_sasl_auth_data() is a helper function defining
the basic functionality for you, but it will store the username and password
in memory. If you choose to use this method you have to call
memcached_destroy_sasl_auth_data before calling memcached_free to avoid
-.TH "MEMCACHED_SASL_SET_AUTH_DATA" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SASL_SET_AUTH_DATA" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_sasl_set_auth_data \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/memcached.h>
-
-void memcached_set_sasl_callbacks(memcached_st *ptr,
- const sasl_callback_t *callbacks)
-
-const sasl_callback_t *memcached_get_sasl_callbacks(memcached_st *ptr)
-
-memcached_return memcached_set_sasl_auth_data(memcached_st *ptr,
- const char *username,
- const char *password)
-memcached_return memcached_destroy_sasl_auth_data(memcached_st *ptr)
-.ft P
-.fi
+#include <libmemcached/memcached_pool.h>
+.INDENT 0.0
+.TP
+.B void memcached_set_sasl_callbacks(memcached_st\fI\ *ptr\fP, const sasl_callback_t\fI\ *callbacks\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const sasl_callback_t *memcached_get_sasl_callbacks(memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return memcached_set_sasl_auth_data(memcached_st\fI\ *ptr\fP, const char\fI\ *username\fP, const char\fI\ *password\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return memcached_destroy_sasl_auth_data(memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) allows you to plug in your own callbacks function used by
Please note that SASL requires the memcached binary protocol, and you have
to specify the callbacks before you connect to the server.
.sp
-memcached_set_sasl_auth_data() is a helper function for you defining
+memcached_set_sasl_auth_data() is a helper function defining
the basic functionality for you, but it will store the username and password
in memory. If you choose to use this method you have to call
memcached_destroy_sasl_auth_data before calling memcached_free to avoid
-.TH "MEMCACHED_SERVER_ADD" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SERVER_ADD" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_server_add \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
+.SH SYNOPSIS
.sp
-Manage server list
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-uint32_t memcached_server_count (memcached_st *ptr);
-
-memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
-
-memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
-
-memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
-
-memcached_server_instance_st memcached_server_get_last_disconnect (const memcached_st *ptr)
-
-memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B uint32_t memcached_server_count (memcached_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_get_last_disconnect(const memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
+.UNINDENT
+.sp
+compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
libmemcached(3) performs operations on a list of hosts. The order of these
hosts determine routing to keys. Functions are provided to add keys to
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
-.SS SEE ALSO
+.SH SEE ALSO
.sp
\fImemcached(1)\fP \fIlibmemcached(3)\fP \fImemcached_strerror(3)\fP
.SH AUTHOR
-.TH "MEMCACHED_SERVER_ADD_UNIX_SOCKET" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SERVER_ADD_UNIX_SOCKET" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_server_add_unix_socket \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
+.SH SYNOPSIS
.sp
-Manage server list
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-uint32_t memcached_server_count (memcached_st *ptr);
-
-memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
-
-memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
-
-memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
-
-memcached_server_instance_st memcached_server_get_last_disconnect (const memcached_st *ptr)
-
-memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B uint32_t memcached_server_count (memcached_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_get_last_disconnect(const memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
+.UNINDENT
+.sp
+compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
libmemcached(3) performs operations on a list of hosts. The order of these
hosts determine routing to keys. Functions are provided to add keys to
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
-.SS SEE ALSO
+.SH SEE ALSO
.sp
\fImemcached(1)\fP \fIlibmemcached(3)\fP \fImemcached_strerror(3)\fP
.SH AUTHOR
-.TH "MEMCACHED_SERVER_COUNT" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SERVER_COUNT" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_server_count \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
+.SH SYNOPSIS
.sp
-Manage server list
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-uint32_t memcached_server_count (memcached_st *ptr);
-
-memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
-
-memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
-
-memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
-
-memcached_server_instance_st memcached_server_get_last_disconnect (const memcached_st *ptr)
-
-memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B uint32_t memcached_server_count (memcached_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_get_last_disconnect(const memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
+.UNINDENT
+.sp
+compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
libmemcached(3) performs operations on a list of hosts. The order of these
hosts determine routing to keys. Functions are provided to add keys to
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
-.SS SEE ALSO
+.SH SEE ALSO
.sp
\fImemcached(1)\fP \fIlibmemcached(3)\fP \fImemcached_strerror(3)\fP
.SH AUTHOR
-.TH "MEMCACHED_SERVER_CURSOR" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SERVER_CURSOR" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_server_cursor \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
+.SH SYNOPSIS
.sp
-Manage server list
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-uint32_t memcached_server_count (memcached_st *ptr);
-
-memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
-
-memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
-
-memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
-
-memcached_server_instance_st memcached_server_get_last_disconnect (const memcached_st *ptr)
-
-memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B uint32_t memcached_server_count (memcached_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_get_last_disconnect(const memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
+.UNINDENT
+.sp
+compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
libmemcached(3) performs operations on a list of hosts. The order of these
hosts determine routing to keys. Functions are provided to add keys to
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
-.SS SEE ALSO
+.SH SEE ALSO
.sp
\fImemcached(1)\fP \fIlibmemcached(3)\fP \fImemcached_strerror(3)\fP
.SH AUTHOR
-.TH "MEMCACHED_SERVER_LIST" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SERVER_LIST" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_server_list \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
+.SH SYNOPSIS
.sp
-Manage server list
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-uint32_t memcached_server_count (memcached_st *ptr);
-
-memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
-
-memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
-
-memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
-
-memcached_server_instance_st memcached_server_get_last_disconnect (const memcached_st *ptr)
-
-memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B uint32_t memcached_server_count (memcached_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_get_last_disconnect(const memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
+.UNINDENT
+.sp
+compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
libmemcached(3) performs operations on a list of hosts. The order of these
hosts determine routing to keys. Functions are provided to add keys to
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
-.SS SEE ALSO
+.SH SEE ALSO
.sp
\fImemcached(1)\fP \fIlibmemcached(3)\fP \fImemcached_strerror(3)\fP
.SH AUTHOR
-.TH "MEMCACHED_SERVER_LIST_APPEND" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SERVER_LIST_APPEND" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_server_list_append \- libmemcached Documentation
.
-.TH "MEMCACHED_SERVER_LIST_COUNT" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SERVER_LIST_COUNT" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_server_list_count \- libmemcached Documentation
.
-.TH "MEMCACHED_SERVER_LIST_FREE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SERVER_LIST_FREE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_server_list_free \- libmemcached Documentation
.
-.TH "MEMCACHED_SERVER_PUSH" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SERVER_PUSH" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_server_push \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
+.SH SYNOPSIS
.sp
-Manage server list
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-uint32_t memcached_server_count (memcached_st *ptr);
-
-memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
-
-memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
-
-memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
-
-memcached_server_instance_st memcached_server_get_last_disconnect (const memcached_st *ptr)
-
-memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B uint32_t memcached_server_count (memcached_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_get_last_disconnect(const memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
+.UNINDENT
+.sp
+compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
libmemcached(3) performs operations on a list of hosts. The order of these
hosts determine routing to keys. Functions are provided to add keys to
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
-.SS SEE ALSO
+.SH SEE ALSO
.sp
\fImemcached(1)\fP \fIlibmemcached(3)\fP \fImemcached_strerror(3)\fP
.SH AUTHOR
-.TH "MEMCACHED_SERVER_ST" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SERVER_ST" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_server_st \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
+.SH SYNOPSIS
.sp
-Manage server list
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-uint32_t memcached_server_count (memcached_st *ptr);
-
-memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
-
-memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
-
-memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
-
-memcached_server_instance_st memcached_server_get_last_disconnect (const memcached_st *ptr)
-
-memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B uint32_t memcached_server_count (memcached_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_get_last_disconnect(const memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
+.UNINDENT
+.sp
+compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
libmemcached(3) performs operations on a list of hosts. The order of these
hosts determine routing to keys. Functions are provided to add keys to
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
-.SS SEE ALSO
+.SH SEE ALSO
.sp
\fImemcached(1)\fP \fIlibmemcached(3)\fP \fImemcached_strerror(3)\fP
.SH AUTHOR
-.TH "MEMCACHED_SERVERS" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SERVERS" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_servers \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
+.SH SYNOPSIS
.sp
-Manage server list
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-uint32_t memcached_server_count (memcached_st *ptr);
-
-memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
-
-memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
-
-memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
-
-memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
-
-memcached_server_instance_st memcached_server_get_last_disconnect (const memcached_st *ptr)
-
-memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B uint32_t memcached_server_count (memcached_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_udp (memcached_st *ptr, const char *hostname, in_port_t port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_add_unix_socket (memcached_st *ptr, const char *socket);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_push (memcached_st *ptr, const memcached_server_st *list);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_by_key (const memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_server_instance_st memcached_server_get_last_disconnect(const memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_server_cursor(const memcached_st *ptr, const memcached_server_fn *callback, void *context, uint32_t number_of_callbacks);
+.UNINDENT
+.sp
+compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
libmemcached(3) performs operations on a list of hosts. The order of these
hosts determine routing to keys. Functions are provided to add keys to
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
-.SS SEE ALSO
+.SH SEE ALSO
.sp
\fImemcached(1)\fP \fIlibmemcached(3)\fP \fImemcached_strerror(3)\fP
.SH AUTHOR
-.TH "MEMCACHED_SERVERS_PARSE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SERVERS_PARSE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_servers_parse \- libmemcached Documentation
.
-.TH "MEMCACHED_SERVERS_RESET" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SERVERS_RESET" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_servers_reset \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Create a memcached_st structure
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
-.TH "MEMCACHED_SET" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SET" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_set \- Storing and Replacing Data
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Store value on server
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.UNINDENT
.INDENT 0.0
.TP
-.B memcached_return_t memcached_prepend(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas(memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_set_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
.INDENT 0.0
.TP
.B memcached_return_t memcached_replace_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_prepend_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
.sp
Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
memcached_set(), memcached_add(), and memcached_replace() are all used to
store information on the server. All methods take a key, and its length to
-store the object. Keys are currently limited to 250 characters by the
-memcached(1) server. You must also supply a value and a length. Optionally you
-may tests an expiration time for the object and a 16 byte value (it is
-meant to be used as a bitmap).
+store the object. Keys are currently limited to 250 characters when using either a version of memcached(1) which is 1.4 or below, or when using the text protocol.
+You must supply both a value and a length. Optionally you
+may test an expiration time for the object and a 16 byte value (it is
+meant to be used as a bitmap). "flags" is a 4byte space that is stored alongside of the main value. Many sub libraries make use of this field, so in most cases users should avoid making use of it.
.sp
memcached_set() will write an object to the server. If an object already
exists it will overwrite what is in the server. If the object does not exist
memcached_add() adds an object to the server. If the object is found on the
server an error occurs, otherwise the value is stored.
.sp
-memcached_prepend() places a segment of data before the last piece of data
-stored. Currently expiration and key are not used in the server.
-.sp
-memcached_append() places a segment of data at the end of the last piece of
-data stored. Currently expiration and key are not used in the server.
-.sp
memcached_cas() overwrites data in the server as long as the "cas" value is
still the same in the server. You can get the cas value of a result by
calling memcached_result_cas() on a memcached_result_st(3) structure. At the point
for it in libmemcached(3) is optional. Please see memcached_set() for
information on how to do this.
.sp
-memcached_set_by_key(), memcached_add_by_key(), memcached_replace_by_key(),
-memcached_prepend_by_key(), memcached_append_by_key_by_key(),
-memcached_cas_by_key() methods all behave in a similar method as the non key
+memcached_set_by_key(), memcached_add_by_key(), and memcached_replace_by_key()
+methods all behave in a similar method as the non key
methods. The difference is that they use their group_key parameter to map
objects to particular servers.
.sp
If you are looking for performance, memcached_set() with non\-blocking IO is
the fastest way to store data on the server.
.sp
-All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. But when using these operations with this behavior on, there
+All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. However, when using these operations with this behavior on, there
are limits to the size of the payload being sent to the server. The reason for
-these limits is that the Memcahed Server does not allow multi\-datagram requests
+these limits is that the Memcached Server does not allow multi\-datagram requests
and the current server implementation sets a datagram size to 1400 bytes. Due
to protocol overhead, the actual limit of the user supplied data is less than
-1400 bytes and depends on the protocol in use as well as the operation being
+1400 bytes and depends on the protocol in use as, well as the operation being
executed. When running with the binary protocol, \(ga\(ga MEMCACHED_BEHAVIOR_BINARY_PROTOCOL\(ga\(ga,
the size of the key,value, flags and expiry combined may not exceed 1368 bytes.
When running with the ASCII protocol, the exact limit fluctuates depending on
\fI\%http://libmemcached.org/\fP
.SH SEE ALSO
.sp
-memcached(1) libmemached(3) memcached_strerror(3)
+memcached(1) libmemached(3) memcached_strerror(3) memcached_prepend(3) memcached_cas(3) memcached_append(3)
.SH AUTHOR
Brian Aker
.SH COPYRIGHT
-.TH "MEMCACHED_SET_BY_KEY" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SET_BY_KEY" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_set_by_key \- Storing and Replacing Data
.
..
.\" Man page generated from reStructeredText.
.
-.sp
-Store value on server
.SH SYNOPSIS
.sp
#include <libmemcached/memcached.h>
.UNINDENT
.INDENT 0.0
.TP
-.B memcached_return_t memcached_prepend(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append(memcached_st\fI\ *ptr\fP, const char\fI\ *key\fP, size_t\fI\ key_length\fP, const char\fI\ *value\fP, size_t\fI\ value_length\fP, time_t\fI\ expiration\fP, uint32_t\fI\ flags\fP)
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas(memcached_st *ptr, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
-.INDENT 0.0
-.TP
.B memcached_return_t memcached_set_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
.INDENT 0.0
.TP
.B memcached_return_t memcached_replace_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_prepend_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_append_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags);
-.UNINDENT
-.INDENT 0.0
-.TP
-.B memcached_return_t memcached_cas_by_key(memcached_st *ptr, const char *group_key, size_t group_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas);
-.UNINDENT
.sp
Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
memcached_set(), memcached_add(), and memcached_replace() are all used to
store information on the server. All methods take a key, and its length to
-store the object. Keys are currently limited to 250 characters by the
-memcached(1) server. You must also supply a value and a length. Optionally you
-may tests an expiration time for the object and a 16 byte value (it is
-meant to be used as a bitmap).
+store the object. Keys are currently limited to 250 characters when using either a version of memcached(1) which is 1.4 or below, or when using the text protocol.
+You must supply both a value and a length. Optionally you
+may test an expiration time for the object and a 16 byte value (it is
+meant to be used as a bitmap). "flags" is a 4byte space that is stored alongside of the main value. Many sub libraries make use of this field, so in most cases users should avoid making use of it.
.sp
memcached_set() will write an object to the server. If an object already
exists it will overwrite what is in the server. If the object does not exist
memcached_add() adds an object to the server. If the object is found on the
server an error occurs, otherwise the value is stored.
.sp
-memcached_prepend() places a segment of data before the last piece of data
-stored. Currently expiration and key are not used in the server.
-.sp
-memcached_append() places a segment of data at the end of the last piece of
-data stored. Currently expiration and key are not used in the server.
-.sp
memcached_cas() overwrites data in the server as long as the "cas" value is
still the same in the server. You can get the cas value of a result by
calling memcached_result_cas() on a memcached_result_st(3) structure. At the point
for it in libmemcached(3) is optional. Please see memcached_set() for
information on how to do this.
.sp
-memcached_set_by_key(), memcached_add_by_key(), memcached_replace_by_key(),
-memcached_prepend_by_key(), memcached_append_by_key_by_key(),
-memcached_cas_by_key() methods all behave in a similar method as the non key
+memcached_set_by_key(), memcached_add_by_key(), and memcached_replace_by_key()
+methods all behave in a similar method as the non key
methods. The difference is that they use their group_key parameter to map
objects to particular servers.
.sp
If you are looking for performance, memcached_set() with non\-blocking IO is
the fastest way to store data on the server.
.sp
-All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. But when using these operations with this behavior on, there
+All of the above functions are testsed with the \fBMEMCACHED_BEHAVIOR_USE_UDP\fPbehavior enabled. However, when using these operations with this behavior on, there
are limits to the size of the payload being sent to the server. The reason for
-these limits is that the Memcahed Server does not allow multi\-datagram requests
+these limits is that the Memcached Server does not allow multi\-datagram requests
and the current server implementation sets a datagram size to 1400 bytes. Due
to protocol overhead, the actual limit of the user supplied data is less than
-1400 bytes and depends on the protocol in use as well as the operation being
+1400 bytes and depends on the protocol in use as, well as the operation being
executed. When running with the binary protocol, \(ga\(ga MEMCACHED_BEHAVIOR_BINARY_PROTOCOL\(ga\(ga,
the size of the key,value, flags and expiry combined may not exceed 1368 bytes.
When running with the ASCII protocol, the exact limit fluctuates depending on
\fI\%http://libmemcached.org/\fP
.SH SEE ALSO
.sp
-memcached(1) libmemached(3) memcached_strerror(3)
+memcached(1) libmemached(3) memcached_strerror(3) memcached_prepend(3) memcached_cas(3) memcached_append(3)
.SH AUTHOR
Brian Aker
.SH COPYRIGHT
-.TH "MEMCACHED_SET_MEMORY_ALLOCATORS" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SET_MEMORY_ALLOCATORS" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_set_memory_allocators \- libmemcached Documentation
.
.
.sp
Manage memory allocator functions
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-memcached_return_t memcached_set_memory_allocators (memcached_st *ptr, memcached_malloc_fn mem_malloc, memcached_free_fn mem_free, memcached_realloc_fn mem_realloc, memcached_calloc_fn mem_calloc, void *context);
-
-void memcached_get_memory_allocators (memcached_st *ptr, memcached_malloc_fn *mem_malloc, memcached_free_fn *mem_free, memcached_realloc_fn *mem_realloc, memcached_calloc_fn *mem_calloc);
-
-void * memcached_get_memory_allocators_context(const memcached_st *ptr);
-
-void * (*memcached_malloc_fn) (memcached_st *ptr, const size_t size, void *context);
-
-void * (*memcached_realloc_fn) (memcached_st *ptr, void *mem, const size_t size, void *context);
-
-void (*memcached_free_fn) (memcached_st *ptr, void *mem, void *context);
-
-void * (*memcached_calloc_fn) (memcached_st *ptr, size_t nelem, const size_t elsize, void *context);
-.ft P
-.fi
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_set_memory_allocators (memcached_st *ptr, memcached_malloc_fn mem_malloc, memcached_free_fn mem_free, memcached_realloc_fn mem_realloc, memcached_calloc_fn mem_calloc, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_get_memory_allocators (memcached_st *ptr, memcached_malloc_fn *mem_malloc, memcached_free_fn *mem_free, memcached_realloc_fn *mem_realloc, memcached_calloc_fn *mem_calloc);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * memcached_get_memory_allocators_context(const memcached_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * (*memcached_malloc_fn) (memcached_st *ptr, const size_t size, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * (*memcached_realloc_fn) (memcached_st *ptr, void *mem, const size_t size, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void (*memcached_free_fn) (memcached_st *ptr, void *mem, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * (*memcached_calloc_fn) (memcached_st *ptr, size_t nelem, const size_t elsize, void *context);
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
-libmemcached(3) allows you to specify your own memory allocators optimized
+libmemcached(3) allows you to specify your own memory allocators, optimized
for your application. This enables libmemcached to be used inside of applications that have their own malloc implementation.
.sp
memcached_set_memory_allocators() is used to set the memory allocators used
-.TH "MEMCACHED_SET_MEMORY_ALLOCATORS_CONTEXT" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SET_MEMORY_ALLOCATORS_CONTEXT" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_set_memory_allocators_context \- libmemcached Documentation
.
.
.sp
Manage memory allocator functions
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-memcached_return_t memcached_set_memory_allocators (memcached_st *ptr, memcached_malloc_fn mem_malloc, memcached_free_fn mem_free, memcached_realloc_fn mem_realloc, memcached_calloc_fn mem_calloc, void *context);
-
-void memcached_get_memory_allocators (memcached_st *ptr, memcached_malloc_fn *mem_malloc, memcached_free_fn *mem_free, memcached_realloc_fn *mem_realloc, memcached_calloc_fn *mem_calloc);
-
-void * memcached_get_memory_allocators_context(const memcached_st *ptr);
-
-void * (*memcached_malloc_fn) (memcached_st *ptr, const size_t size, void *context);
-
-void * (*memcached_realloc_fn) (memcached_st *ptr, void *mem, const size_t size, void *context);
-
-void (*memcached_free_fn) (memcached_st *ptr, void *mem, void *context);
-
-void * (*memcached_calloc_fn) (memcached_st *ptr, size_t nelem, const size_t elsize, void *context);
-.ft P
-.fi
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_set_memory_allocators (memcached_st *ptr, memcached_malloc_fn mem_malloc, memcached_free_fn mem_free, memcached_realloc_fn mem_realloc, memcached_calloc_fn mem_calloc, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void memcached_get_memory_allocators (memcached_st *ptr, memcached_malloc_fn *mem_malloc, memcached_free_fn *mem_free, memcached_realloc_fn *mem_realloc, memcached_calloc_fn *mem_calloc);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * memcached_get_memory_allocators_context(const memcached_st *ptr);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * (*memcached_malloc_fn) (memcached_st *ptr, const size_t size, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * (*memcached_realloc_fn) (memcached_st *ptr, void *mem, const size_t size, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void (*memcached_free_fn) (memcached_st *ptr, void *mem, void *context);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B void * (*memcached_calloc_fn) (memcached_st *ptr, size_t nelem, const size_t elsize, void *context);
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
-libmemcached(3) allows you to specify your own memory allocators optimized
+libmemcached(3) allows you to specify your own memory allocators, optimized
for your application. This enables libmemcached to be used inside of applications that have their own malloc implementation.
.sp
memcached_set_memory_allocators() is used to set the memory allocators used
-.TH "MEMCACHED_SET_SASL_CALLBACKS" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SET_SASL_CALLBACKS" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_set_sasl_callbacks \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
.SH SYNOPSIS
.sp
-.nf
-.ft C
-#include <libmemcached/memcached.h>
-
-void memcached_set_sasl_callbacks(memcached_st *ptr,
- const sasl_callback_t *callbacks)
-
-const sasl_callback_t *memcached_get_sasl_callbacks(memcached_st *ptr)
-
-memcached_return memcached_set_sasl_auth_data(memcached_st *ptr,
- const char *username,
- const char *password)
-memcached_return memcached_destroy_sasl_auth_data(memcached_st *ptr)
-.ft P
-.fi
+#include <libmemcached/memcached_pool.h>
+.INDENT 0.0
+.TP
+.B void memcached_set_sasl_callbacks(memcached_st\fI\ *ptr\fP, const sasl_callback_t\fI\ *callbacks\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B const sasl_callback_t *memcached_get_sasl_callbacks(memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return memcached_set_sasl_auth_data(memcached_st\fI\ *ptr\fP, const char\fI\ *username\fP, const char\fI\ *password\fP)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return memcached_destroy_sasl_auth_data(memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
.SH DESCRIPTION
.sp
libmemcached(3) allows you to plug in your own callbacks function used by
Please note that SASL requires the memcached binary protocol, and you have
to specify the callbacks before you connect to the server.
.sp
-memcached_set_sasl_auth_data() is a helper function for you defining
+memcached_set_sasl_auth_data() is a helper function defining
the basic functionality for you, but it will store the username and password
in memory. If you choose to use this method you have to call
memcached_destroy_sasl_auth_data before calling memcached_free to avoid
-.TH "MEMCACHED_SET_USER_DATA" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_SET_USER_DATA" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_set_user_data \- libmemcached Documentation
.
.SH LIBRARY
.sp
C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
+.SH SYNOPSIS
.sp
.nf
.ft C
void *memcached_set_user_data (memcached_st *ptr, void *data);
.ft P
.fi
-.SS DESCRIPTION
+.SH DESCRIPTION
.sp
libmemcached(3) allows you to store a pointer to a user specific data inside
the memcached_st structure.
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
-.SH AUTHOR
-.sp
-Trond Norbye, <\fI\%trond.norbye@gmail.com\fP>
-.SS SEE ALSO
+.SH SEE ALSO
.sp
memcached(1) libmemcached(3)
.SH AUTHOR
-.TH "MEMCACHED_STAT" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_STAT" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_stat \- libmemcached Documentation
.
.
.sp
Get memcached statistics
-.SH LIBRARY
+.SH SYNOPSIS
.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-memcached_stat_st *memcached_stat (memcached_st *ptr,
- char *args,
- memcached_return_t *error);
-
-memcached_return_t memcached_stat_servername (memcached_stat_st *stat,
- char *args,
- const char *hostname,
- unsigned int port);
-
-char *
- memcached_stat_get_value (memcached_st *ptr,
- memcached_stat_st *stat,
- const char *key,
- memcached_return_t *error);
-
-char **
- memcached_stat_get_keys (memcached_st *ptr,
- memcached_stat_st *stat,
- memcached_return_t *error);
-
-memcached_return_t
- memcached_stat_execute (memcached_st *memc,
- const char *args,
- memcached_stat_fn func,
- void *context);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B memcached_stat_st *memcached_stat (memcached_st *ptr, char *args, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_stat_servername (memcached_stat_st *stat, char *args, const char *hostname, unsigned int port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B char * memcached_stat_get_value (memcached_st *ptr, memcached_stat_st *stat, const char *key, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B char ** memcached_stat_get_keys (memcached_st *ptr, memcached_stat_st *stat, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_stat_execute (memcached_st *memc, const char *args, memcached_stat_fn func, void *context);
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
libmemcached(3) has the ability to query a memcached server (or collection
of servers) for their current state. Queries to find state return a
.SH AUTHOR
.sp
Brian Aker, <\fI\%brian@tangent.org\fP>
-.SS SEE ALSO
+.SH SEE ALSO
.sp
memcached(1) libmemcached(3) memcached_strerror(3)
.SH AUTHOR
-.TH "MEMCACHED_STAT_EXECUTE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_STAT_EXECUTE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_stat_execute \- libmemcached Documentation
.
.
.sp
Get memcached statistics
-.SH LIBRARY
+.SH SYNOPSIS
.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-memcached_stat_st *memcached_stat (memcached_st *ptr,
- char *args,
- memcached_return_t *error);
-
-memcached_return_t memcached_stat_servername (memcached_stat_st *stat,
- char *args,
- const char *hostname,
- unsigned int port);
-
-char *
- memcached_stat_get_value (memcached_st *ptr,
- memcached_stat_st *stat,
- const char *key,
- memcached_return_t *error);
-
-char **
- memcached_stat_get_keys (memcached_st *ptr,
- memcached_stat_st *stat,
- memcached_return_t *error);
-
-memcached_return_t
- memcached_stat_execute (memcached_st *memc,
- const char *args,
- memcached_stat_fn func,
- void *context);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B memcached_stat_st *memcached_stat (memcached_st *ptr, char *args, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_stat_servername (memcached_stat_st *stat, char *args, const char *hostname, unsigned int port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B char * memcached_stat_get_value (memcached_st *ptr, memcached_stat_st *stat, const char *key, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B char ** memcached_stat_get_keys (memcached_st *ptr, memcached_stat_st *stat, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_stat_execute (memcached_st *memc, const char *args, memcached_stat_fn func, void *context);
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
libmemcached(3) has the ability to query a memcached server (or collection
of servers) for their current state. Queries to find state return a
.SH AUTHOR
.sp
Brian Aker, <\fI\%brian@tangent.org\fP>
-.SS SEE ALSO
+.SH SEE ALSO
.sp
memcached(1) libmemcached(3) memcached_strerror(3)
.SH AUTHOR
-.TH "MEMCACHED_STAT_GET_KEYS" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_STAT_GET_KEYS" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_stat_get_keys \- libmemcached Documentation
.
.
.sp
Get memcached statistics
-.SH LIBRARY
+.SH SYNOPSIS
.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-memcached_stat_st *memcached_stat (memcached_st *ptr,
- char *args,
- memcached_return_t *error);
-
-memcached_return_t memcached_stat_servername (memcached_stat_st *stat,
- char *args,
- const char *hostname,
- unsigned int port);
-
-char *
- memcached_stat_get_value (memcached_st *ptr,
- memcached_stat_st *stat,
- const char *key,
- memcached_return_t *error);
-
-char **
- memcached_stat_get_keys (memcached_st *ptr,
- memcached_stat_st *stat,
- memcached_return_t *error);
-
-memcached_return_t
- memcached_stat_execute (memcached_st *memc,
- const char *args,
- memcached_stat_fn func,
- void *context);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B memcached_stat_st *memcached_stat (memcached_st *ptr, char *args, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_stat_servername (memcached_stat_st *stat, char *args, const char *hostname, unsigned int port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B char * memcached_stat_get_value (memcached_st *ptr, memcached_stat_st *stat, const char *key, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B char ** memcached_stat_get_keys (memcached_st *ptr, memcached_stat_st *stat, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_stat_execute (memcached_st *memc, const char *args, memcached_stat_fn func, void *context);
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
libmemcached(3) has the ability to query a memcached server (or collection
of servers) for their current state. Queries to find state return a
.SH AUTHOR
.sp
Brian Aker, <\fI\%brian@tangent.org\fP>
-.SS SEE ALSO
+.SH SEE ALSO
.sp
memcached(1) libmemcached(3) memcached_strerror(3)
.SH AUTHOR
-.TH "MEMCACHED_STAT_GET_VALUE" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_STAT_GET_VALUE" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_stat_get_value \- libmemcached Documentation
.
.
.sp
Get memcached statistics
-.SH LIBRARY
+.SH SYNOPSIS
.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-memcached_stat_st *memcached_stat (memcached_st *ptr,
- char *args,
- memcached_return_t *error);
-
-memcached_return_t memcached_stat_servername (memcached_stat_st *stat,
- char *args,
- const char *hostname,
- unsigned int port);
-
-char *
- memcached_stat_get_value (memcached_st *ptr,
- memcached_stat_st *stat,
- const char *key,
- memcached_return_t *error);
-
-char **
- memcached_stat_get_keys (memcached_st *ptr,
- memcached_stat_st *stat,
- memcached_return_t *error);
-
-memcached_return_t
- memcached_stat_execute (memcached_st *memc,
- const char *args,
- memcached_stat_fn func,
- void *context);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B memcached_stat_st *memcached_stat (memcached_st *ptr, char *args, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_stat_servername (memcached_stat_st *stat, char *args, const char *hostname, unsigned int port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B char * memcached_stat_get_value (memcached_st *ptr, memcached_stat_st *stat, const char *key, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B char ** memcached_stat_get_keys (memcached_st *ptr, memcached_stat_st *stat, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_stat_execute (memcached_st *memc, const char *args, memcached_stat_fn func, void *context);
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
libmemcached(3) has the ability to query a memcached server (or collection
of servers) for their current state. Queries to find state return a
.SH AUTHOR
.sp
Brian Aker, <\fI\%brian@tangent.org\fP>
-.SS SEE ALSO
+.SH SEE ALSO
.sp
memcached(1) libmemcached(3) memcached_strerror(3)
.SH AUTHOR
-.TH "MEMCACHED_STAT_SERVERNAME" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_STAT_SERVERNAME" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_stat_servername \- libmemcached Documentation
.
.
.sp
Get memcached statistics
-.SH LIBRARY
+.SH SYNOPSIS
.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-memcached_stat_st *memcached_stat (memcached_st *ptr,
- char *args,
- memcached_return_t *error);
-
-memcached_return_t memcached_stat_servername (memcached_stat_st *stat,
- char *args,
- const char *hostname,
- unsigned int port);
-
-char *
- memcached_stat_get_value (memcached_st *ptr,
- memcached_stat_st *stat,
- const char *key,
- memcached_return_t *error);
-
-char **
- memcached_stat_get_keys (memcached_st *ptr,
- memcached_stat_st *stat,
- memcached_return_t *error);
-
-memcached_return_t
- memcached_stat_execute (memcached_st *memc,
- const char *args,
- memcached_stat_fn func,
- void *context);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B memcached_stat_st *memcached_stat (memcached_st *ptr, char *args, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_stat_servername (memcached_stat_st *stat, char *args, const char *hostname, unsigned int port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B char * memcached_stat_get_value (memcached_st *ptr, memcached_stat_st *stat, const char *key, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B char ** memcached_stat_get_keys (memcached_st *ptr, memcached_stat_st *stat, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_stat_execute (memcached_st *memc, const char *args, memcached_stat_fn func, void *context);
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
libmemcached(3) has the ability to query a memcached server (or collection
of servers) for their current state. Queries to find state return a
.SH AUTHOR
.sp
Brian Aker, <\fI\%brian@tangent.org\fP>
-.SS SEE ALSO
+.SH SEE ALSO
.sp
memcached(1) libmemcached(3) memcached_strerror(3)
.SH AUTHOR
-.TH "MEMCACHED_STATS" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_STATS" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_stats \- libmemcached Documentation
.
.
.sp
Get memcached statistics
-.SH LIBRARY
+.SH SYNOPSIS
.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-memcached_stat_st *memcached_stat (memcached_st *ptr,
- char *args,
- memcached_return_t *error);
-
-memcached_return_t memcached_stat_servername (memcached_stat_st *stat,
- char *args,
- const char *hostname,
- unsigned int port);
-
-char *
- memcached_stat_get_value (memcached_st *ptr,
- memcached_stat_st *stat,
- const char *key,
- memcached_return_t *error);
-
-char **
- memcached_stat_get_keys (memcached_st *ptr,
- memcached_stat_st *stat,
- memcached_return_t *error);
-
-memcached_return_t
- memcached_stat_execute (memcached_st *memc,
- const char *args,
- memcached_stat_fn func,
- void *context);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B memcached_stat_st *memcached_stat (memcached_st *ptr, char *args, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_stat_servername (memcached_stat_st *stat, char *args, const char *hostname, unsigned int port);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B char * memcached_stat_get_value (memcached_st *ptr, memcached_stat_st *stat, const char *key, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B char ** memcached_stat_get_keys (memcached_st *ptr, memcached_stat_st *stat, memcached_return_t *error);
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_stat_execute (memcached_st *memc, const char *args, memcached_stat_fn func, void *context);
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
libmemcached(3) has the ability to query a memcached server (or collection
of servers) for their current state. Queries to find state return a
.SH AUTHOR
.sp
Brian Aker, <\fI\%brian@tangent.org\fP>
-.SS SEE ALSO
+.SH SEE ALSO
.sp
memcached(1) libmemcached(3) memcached_strerror(3)
.SH AUTHOR
-.TH "MEMCACHED_STRERROR" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_STRERROR" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_strerror \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
-.SH LIBRARY
+.SH SYNOPSIS
.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-const char *
- memcached_strerror (memcached_st *ptr,
- memcached_return_t rc);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B const char * memcached_strerror (memcached_st *ptr, memcached_return_t rc);
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
memcached_strerror() takes a \fBmemcached_return_t\fP value and returns a string
describing the error.
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
-.SH AUTHOR
-.sp
-Brian Aker, <\fI\%brian@tangent.org\fP>
-.SS SEE ALSO
+.SH SEE ALSO
.sp
memcached(1) libmemcached(3)
.SH AUTHOR
-.TH "MEMCACHED_USER_DATA" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_USER_DATA" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_user_data \- libmemcached Documentation
.
.SH LIBRARY
.sp
C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
+.SH SYNOPSIS
.sp
.nf
.ft C
void *memcached_set_user_data (memcached_st *ptr, void *data);
.ft P
.fi
-.SS DESCRIPTION
+.SH DESCRIPTION
.sp
libmemcached(3) allows you to store a pointer to a user specific data inside
the memcached_st structure.
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
-.SH AUTHOR
-.sp
-Trond Norbye, <\fI\%trond.norbye@gmail.com\fP>
-.SS SEE ALSO
+.SH SEE ALSO
.sp
memcached(1) libmemcached(3)
.SH AUTHOR
-.TH "MEMCACHED_VERBOSITY" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_VERBOSITY" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_verbosity \- libmemcached Documentation
.
.
.sp
Modifiy verbosity of servers
-.SH LIBRARY
+.SH SYNOPSIS
.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-memcached_return_t
- memcached_verbosity (memcached_st *ptr,
- unsigned int verbosity);
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_verbosity (memcached_st *ptr, unsigned int verbosity);
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
memcached_verbosity() modifies the "verbosity" of the
memcached(1) servers referenced in the \fBmemcached_st\fP parameter.
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
-.SH AUTHOR
-.sp
-Brian Aker, <\fI\%brian@tangent.org\fP>
-.SS SEE ALSO
+.SH SEE ALSO
.sp
memcached(1) libmemcached(3) memcached_strerror(3)
.SH AUTHOR
-.TH "MEMCACHED_VERSION" "3" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCACHED_VERSION" "3" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcached_version \- libmemcached Documentation
.
..
.\" Man page generated from reStructeredText.
.
+.SH SYNOPSIS
.sp
-Get library version
-.SH LIBRARY
-.sp
-C Client Library for memcached (libmemcached, \-lmemcached)
-.SS SYNOPSIS
-.sp
-.nf
-.ft C
#include <libmemcached/memcached.h>
-
-const char *
- memcached_lib_version (void)
-
-
-memcached_return_t
- memcached_version (memcached_st *ptr)
-.ft P
-.fi
-.SS DESCRIPTION
+.INDENT 0.0
+.TP
+.B const char * memcached_lib_version(void)
+.UNINDENT
+.INDENT 0.0
+.TP
+.B memcached_return_t memcached_version(memcached_st\fI\ *ptr\fP)
+.UNINDENT
+.sp
+Compile and link with \-lmemcached
+.SH DESCRIPTION
.sp
memcached_lib_version() is used to return a simple version string representing
-the libmemcached version (version of the client library, not server)
+the libmemcached version (client library version, not server version)
.sp
memcached_version() is used to set the major, minor, and micro versions of each
memcached server being used by the memcached_st connection structure. It returns the
.sp
To find out more information please check:
\fI\%http://libmemcached.org/\fP
-.SH AUTHOR
-.sp
-Brian Aker, <\fI\%brian@tangent.org\fP>
-.SS SEE ALSO
+.SH SEE ALSO
.sp
memcached(1) libmemcached(3) memcached_strerror(3)
.SH AUTHOR
-.TH "MEMCAPABLE" "1" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCAPABLE" "1" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcapable \- libmemcached Documentation
.
.INDENT 0.0
.TP
.B \-h hostname
+.UNINDENT
.sp
Specify the hostname to connect to. The default is \fIlocalhost\fP
-.UNINDENT
.INDENT 0.0
.TP
.B \-p port
+.UNINDENT
.sp
Specify the port number to connect to. The default is \fI11211\fP
-.UNINDENT
.INDENT 0.0
.TP
.B \-c
-.
-Generate a coredump when it detects an error from the server.
.UNINDENT
+.sp
+Generate a coredump when it detects an error from the server.
.INDENT 0.0
.TP
.B \-v
-.
-Print out the comparison when it detects an error from the server.
.UNINDENT
+.sp
+Print out the comparison when it detects an error from the server.
.INDENT 0.0
.TP
.B \-t n
+.UNINDENT
.sp
Set the timeout from an IO operation to/from the server to \fIn\fP seconds.
-.UNINDENT
.SH DESCRIPTION
.sp
\fBmemcapable\fP connects to the specified memcached server and tries to
-.TH "MEMCAT" "1" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCAT" "1" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcat \- libmemcached Documentation
.
-.TH "MEMCP" "1" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMCP" "1" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memcp \- libmemcached Documentation
.
It is similar to the standard UNIX cp(1) command.
.sp
The key names will be the names of the files,
-without any directory path part.
+without any directory path.
.sp
You can specify servers via the \fB\-\-servers\fP option or via the
-environment variable \fBMEMCACHED_SERVERS\fP. If you specify neither of
-these, the final value in the command line list is the name of a
+environment variable \fBMEMCACHED_SERVERS\fP. If you do not specify either these, the final value in the command line list is the name of a
server(s).
.sp
For a full list of operations run the tool with the \fB\-\-help\fP option.
-.TH "MEMDUMP" "1" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMDUMP" "1" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memdump \- libmemcached Documentation
.
.UNINDENT
.SH DESCRIPTION
.sp
-\fBmemdump\fP currently dumps a list of "keys" from all servers that
+\fBmemdump\fP dumps a list of "keys" from all servers that
it is told to fetch from. Because memcached does not guarentee to
provide all keys it is not possible to get a complete "dump".
.sp
-.TH "MEMERROR" "1" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMERROR" "1" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memerror \- libmemcached Documentation
.
.\" Man page generated from reStructeredText.
.
.sp
-Translate a memcached error code to a string
+Translates a memcached error code into a string
.SH SYNOPSIS
.INDENT 0.0
.TP
.UNINDENT
.SH DESCRIPTION
.sp
-\fBmemerror\fP translate an error code from libmemcached(3) to a human
+\fBmemerror\fP translate an error code from libmemcached(3) into a human
readable string.
.sp
For a full list of operations run the tool with the \fB\-\-help\fP option.
-.SS HOME
+.SH HOME
.sp
To find out more infoerroration please check:
\fI\%http://libmemcached.org/\fP
-.SS AUTHOR
-.sp
-Brian Aker, <\fI\%brian@tangent.org\fP>
.SH SEE ALSO
.sp
memcached(1) libmemcached(3)
-.TH "MEMFLUSH" "1" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMFLUSH" "1" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memflush \- libmemcached Documentation
.
.SH DESCRIPTION
.sp
\fBmemflush\fP resets the contents of memcached(1) servers.
-This means all data in these servers will be deleted.
+This means that all data in the specified servers will be deleted.
.sp
You can specify servers via the \fB\-\-servers\fP option or via the
environment variable \fBMEMCACHED_SERVERS\fP.
-.TH "MEMRM" "1" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMRM" "1" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memrm \- libmemcached Documentation
.
-.TH "MEMSLAP" "1" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMSLAP" "1" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memslap \- libmemcached Documentation
.
.SH DESCRIPTION
.sp
\fBmemslap\fP is a load generation and benchmark tool for memcached(1)
-servers. It generates configurable workload such as threads, concurrencies, connections,
-run time, overwrite, miss rate, key size, value size, get/set proportion,
-expected throughput, and so on.
+servers. It generates configurable workload such as threads, concurrencies, connections, run time, overwrite, miss rate, key size, value size, get/set proportion, expected throughput, and so on.
.sp
-You can specify servers via the \fB\-\-servers\fP option or via the
-environment variable \fBMEMCACHED_SERVERS\fP.
+You can specify servers via the \fB\-\-servers\fP option or via the environment variable \fBMEMCACHED_SERVERS\fP.
.SH SEE ALSO
.sp
\fImemcached(1)\fP \fIlibmemcached(3)\fP
-.TH "MEMSTAT" "1" "April 14, 2011" "0.47" "libmemcached"
+.TH "MEMSTAT" "1" "May 23, 2011" "0.47" "libmemcached"
.SH NAME
memstat \- libmemcached Documentation
.
projects / awesomized / libmemcached / commitdiff
