fluidB
/
fluexec
1
0
Fork 0
Code Pull Requests Activity

update API documentation

Browse Source
master
Dvir Volk 8 years ago
parent 32f7aa2b3b
commit ee491bb0ee
1 changed files with 496 additions and 29 deletions
Show Stats Download Patch File Download Diff File

525
FUNCTIONS.md
Unescape Escape View File

@ -1,4 +1,3 @@
# Generated API for Redis Modules and Redis Module Utils
## module.c
* [RedisModule_FreeCallReply](#redismodule_freecallreply)
@ -7,6 +6,18 @@
* [RedisModule_ZsetRangeStop](#redismodule_zsetrangestop)
* [RedisModule_Alloc](#redismodule_alloc)
* [RedisModule_Calloc](#redismodule_calloc)
* [RedisModule_Realloc](#redismodule_realloc)
* [RedisModule_Free](#redismodule_free)
* [RedisModule_Strdup](#redismodule_strdup)
* [RedisModule_PoolAlloc](#redismodule_poolalloc)
* [RedisModule_GetApi](#redismodule_getapi)
* [RedisModule_IsKeysPositionRequest](#redismodule_iskeyspositionrequest)
@ -21,16 +32,26 @@
* [RedisModule_CreateString](#redismodule_createstring)
* [RedisModule_CreateStringPrintf](#redismodule_createstringprintf)
* [RedisModule_CreateStringFromLongLong](#redismodule_createstringfromlonglong)
* [RedisModule_CreateStringFromString](#redismodule_createstringfromstring)
* [RedisModule_FreeString](#redismodule_freestring)
* [RedisModule_RetainString](#redismodule_retainstring)
* [RedisModule_StringPtrLen](#redismodule_stringptrlen)
* [RedisModule_StringToLongLong](#redismodule_stringtolonglong)
* [RedisModule_StringToDouble](#redismodule_stringtodouble)
* [RedisModule_StringCompare](#redismodule_stringcompare)
* [RedisModule_StringAppendBuffer](#redismodule_stringappendbuffer)
* [RedisModule_WrongArity](#redismodule_wrongarity)
* [RedisModule_ReplyWithLongLong](#redismodule_replywithlonglong)
@ -141,6 +162,48 @@
* [RedisModule_CallReplyProto](#redismodule_callreplyproto)
* [RedisModule_CreateDataType](#redismodule_createdatatype)
* [RedisModule_ModuleTypeSetValue](#redismodule_moduletypesetvalue)
* [RedisModule_ModuleTypeGetType](#redismodule_moduletypegettype)
* [RedisModule_ModuleTypeGetValue](#redismodule_moduletypegetvalue)
* [RedisModule_SaveUnsigned](#redismodule_saveunsigned)
* [RedisModule_LoadUnsigned](#redismodule_loadunsigned)
* [RedisModule_SaveSigned](#redismodule_savesigned)
* [RedisModule_LoadSigned](#redismodule_loadsigned)
* [RedisModule_SaveString](#redismodule_savestring)
* [RedisModule_SaveStringBuffer](#redismodule_savestringbuffer)
* [RedisModule_LoadString](#redismodule_loadstring)
* [RedisModule_LoadStringBuffer](#redismodule_loadstringbuffer)
* [RedisModule_SaveDouble](#redismodule_savedouble)
* [RedisModule_LoadDouble](#redismodule_loaddouble)
* [RedisModule_SaveFloat](#redismodule_savefloat)
* [RedisModule_LoadFloat](#redismodule_loadfloat)
* [RedisModule_EmitAOF](#redismodule_emitaof)
* [RedisModule_GetContextFromIO](#redismodule_getcontextfromio)
* [RedisModule_LogRaw](#redismodule_lograw)
* [RedisModule_Log](#redismodule_log)
* [RedisModule_LogIOError](#redismodule_logioerror)
## util.h
* [RMUtil_ArgExists](#rmutil_argexists)
@ -155,6 +218,8 @@
* [RMUtil_StringEquals](#rmutil_stringequals)
* [RMUtil_StringEqualsC](#rmutil_stringequalsc)
* [RMUtil_StringToLower](#rmutil_stringtolower)
* [RMUtil_StringToUpper](#rmutil_stringtoupper)
@ -162,6 +227,8 @@
## vector.h
* [Vector_Get](#vector_get)
* [Vector_Pop](#vector_pop)
* [Vector_Resize](#vector_resize)
* [Vector_Size](#vector_size)
@ -189,13 +256,74 @@ void RedisModule_CloseKey(RedisModuleKey *key);
### RedisModule_ZsetRangeStop
```
void RedisModule_ZsetRangeStop(RedisModuleKey *key);
void RedisModule_ZsetRangeStop(RedisModuleKey *kp);
```
--------------------------------------------------------------------------
Prototypes
--------------------------------------------------------------------------
### RedisModule_Alloc
```
void *RedisModule_Alloc(size_t bytes) {
```
Use like malloc(). Memory allocated with this function is reported in
Redis INFO memory, used for keys eviction according to maxmemory settings
and in general is taken into account as memory allocated by Redis.
You should avoid using malloc().
### RedisModule_Calloc
```
void *RedisModule_Calloc(size_t nmemb, size_t size) {
```
Use like calloc(). Memory allocated with this function is reported in
Redis INFO memory, used for keys eviction according to maxmemory settings
and in general is taken into account as memory allocated by Redis.
You should avoid using calloc() directly.
### RedisModule_Realloc
```
void* RedisModule_Realloc(void *ptr, size_t bytes) {
```
Use like realloc() for memory obtained with RedisModule_Alloc().
### RedisModule_Free
```
void RedisModule_Free(void *ptr) {
```
Use like free() for memory obtained by RedisModule_Alloc() and
RedisModule_Realloc(). However you should never try to free with
RedisModule_Free() memory allocated with malloc() inside your module.
### RedisModule_Strdup
```
char *RedisModule_Strdup(const char *str) {
```
Like strdup() but returns memory allocated with RedisModule_Alloc().
### RedisModule_PoolAlloc
```
void *RedisModule_PoolAlloc(RedisModuleCtx *ctx, size_t bytes) {
```
Return heap allocated memory that will be freed automatically when the
module callback function returns. Mostly suitable for small allocations
that are short living and must be released when the callback returns
anyway. The returned memory is aligned to the architecture word size
if at least word size bytes are requested, otherwise it is just
aligned to the next power of two, so for example a 3 bytes request is
4 bytes aligned while a 2 bytes request is 2 bytes aligned.
There is no realloc style function since when this is needed to use the
pool allocator is not a good idea.
The function returns NULL if `bytes` is 0.
### RedisModule_GetApi
```
int RedisModule_GetApi(const char *funcname, void **targetPtrPtr) {
@ -253,7 +381,7 @@ int RedisModule_CreateCommand(RedisModuleCtx *ctx, const char *name, RedisModule
The command function type is the following:
int MyCommand_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc);
int MyCommand_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc);
And is supposed to always return REDISMODULE_OK.
@ -299,7 +427,7 @@ int RedisModule_CreateCommand(RedisModuleCtx *ctx, const char *name, RedisModule
```
void RedisModule_SetModuleAttribs(RedisModuleCtx *ctx, const char *name, int ver, int apiver){
```
Called by RM_Init() to setup the ctx->module structure.
Called by RM_Init() to setup the `ctx->module` structure.
This is an internal function, Redis modules developers don't need
to use it.
@ -317,7 +445,7 @@ void RedisModule_AutoMemory(RedisModuleCtx *ctx) {
### RedisModule_CreateString
```
RedisModuleString *RedisModule_CreateString(RedisModuleCtx *ctx, const char *ptr, size_t len)
RedisModuleString *RedisModule_CreateString(RedisModuleCtx *ctx, const char *ptr, size_t len) {
```
Create a new module string object. The returned string must be freed
with RedisModule_FreeString(), unless automatic memory is enabled.
@ -326,6 +454,17 @@ RedisModuleString *RedisModule_CreateString(RedisModuleCtx *ctx, const char *ptr
at `ptr`. No reference is retained to the passed buffer.
### RedisModule_CreateStringPrintf
```
RedisModuleString *RedisModule_CreateStringPrintf(RedisModuleCtx *ctx, const char *fmt, ...) {
```
Create a new module string object from a printf format and arguments.
The returned string must be freed with RedisModule_FreeString(), unless automatic
memory is enabled.
The string is created using the sds formatter function sdscatvprintf()
### RedisModule_CreateStringFromLongLong
```
RedisModuleString *RedisModule_CreateStringFromLongLong(RedisModuleCtx *ctx, long long ll) {
@ -337,6 +476,17 @@ RedisModuleString *RedisModule_CreateStringFromLongLong(RedisModuleCtx *ctx, lon
enabling automatic memory management.
### RedisModule_CreateStringFromString
```
RedisModuleString *RedisModule_CreateStringFromString(RedisModuleCtx *ctx, const RedisModuleString *str) {
```
Like RedisModule_CreatString(), but creates a string starting from another
RedisModuleString.
The returned string must be released with RedisModule_FreeString() or by
enabling automatic memory management.
### RedisModule_FreeString
```
void RedisModule_FreeString(RedisModuleCtx *ctx, RedisModuleString *str) {
@ -349,9 +499,37 @@ void RedisModule_FreeString(RedisModuleCtx *ctx, RedisModuleString *str) {
from the pool of string to release at the end.
### RedisModule_RetainString
```
void RedisModule_RetainString(RedisModuleCtx *ctx, RedisModuleString *str) {
```
Every call to this function, will make the string 'str' requiring
an additional call to RedisModule_FreeString() in order to really
free the string. Note that the automatic freeing of the string obtained
enabling modules automatic memory management counts for one
RedisModule_FreeString() call (it is just executed automatically).
Normally you want to call this function when, at the same time
the following conditions are true:
1) You have automatic memory management enabled.
2) You want to create string objects.
3) Those string objects you create need to live *after* the callback
function(for example a command implementation) creating them returns.
Usually you want this in order to store the created string object
into your own data structure, for example when implementing a new data
type.
Note that when memory management is turned off, you don't need
any call to RetainString() since creating a string will always result
into a string that lives after the callback function returns, if
no FreeString() call is performed.
### RedisModule_StringPtrLen
```
const char *RedisModule_StringPtrLen(RedisModuleString *str, size_t *len) {
const char *RedisModule_StringPtrLen(const RedisModuleString *str, size_t *len) {
```
Given a string module object, this function returns the string pointer
and length of the string. The returned pointer and length should only
@ -360,9 +538,9 @@ const char *RedisModule_StringPtrLen(RedisModuleString *str, size_t *len) {
### RedisModule_StringToLongLong
```
int RedisModule_StringToLongLong(RedisModuleString *str, long long *ll) {
int RedisModule_StringToLongLong(const RedisModuleString *str, long long *ll) {
```
Convert the string into a long long integer, storing it at *ll.
Convert the string into a long long integer, storing it at `*ll`.
Returns REDISMODULE_OK on success. If the string can't be parsed
as a valid, strict long long (no spaces before/after), REDISMODULE_ERR
is returned.
@ -370,13 +548,31 @@ int RedisModule_StringToLongLong(RedisModuleString *str, long long *ll) {
### RedisModule_StringToDouble
```
int RedisModule_StringToDouble(RedisModuleString *str, double *d) {
int RedisModule_StringToDouble(const RedisModuleString *str, double *d) {
```
Convert the string into a double, storing it at *d.
Convert the string into a double, storing it at `*d`.
Returns REDISMODULE_OK on success or REDISMODULE_ERR if the string is
not a valid string representation of a double value.
### RedisModule_StringCompare
```
int RedisModule_StringCompare(RedisModuleString *a, RedisModuleString *b) {
```
Compare two string objects, returning -1, 0 or 1 respectively if
a < b, a == b, a > b. Strings are compared byte by byte as two
binary blobs without any encoding care / collation attempt.
### RedisModule_StringAppendBuffer
```
int RedisModule_StringAppendBuffer(RedisModuleCtx *ctx, RedisModuleString *str, const char *buf, size_t len) {
```
Append the specified buffere to the string 'str'. The string must be a
string created by the user that is referenced only a single time, otherwise
REDISMODULE_ERR is returend and the operation is not performed.
### RedisModule_WrongArity
```
int RedisModule_WrongArity(RedisModuleCtx *ctx) {
@ -432,7 +628,7 @@ int RedisModule_ReplyWithSimpleString(RedisModuleCtx *ctx, const char *msg) {
int RedisModule_ReplyWithArray(RedisModuleCtx *ctx, long len) {
```
Reply with an array type of 'len' elements. However 'len' other calls
to ReplyWith* style functions must follow in order to emit the elements
to `ReplyWith*` style functions must follow in order to emit the elements
of the array.
When producing arrays with a number of element that is not known beforehand
@ -817,9 +1013,9 @@ int RedisModule_ZsetAdd(RedisModuleKey *key, double score, RedisModuleString *el
On success the function returns REDISMODULE_OK. On the following errors
REDISMODULE_ERR is returned:
- The key was not opened for writing.
- The key is of the wrong type.
- 'score' double value is not a number (NaN).
* The key was not opened for writing.
* The key is of the wrong type.
* 'score' double value is not a number (NaN).
### RedisModule_ZsetIncrby
@ -849,8 +1045,8 @@ int RedisModule_ZsetRem(RedisModuleKey *key, RedisModuleString *ele, int *delete
The function returns REDISMODULE_OK on success, and REDISMODULE_ERR
on one of the following conditions:
- The key was not opened for writing.
- The key is of the wrong type.
* The key was not opened for writing.
* The key is of the wrong type.
The return value does NOT indicate the fact the element was really
removed (since it existed) or not, just if the function was executed
@ -873,9 +1069,9 @@ int RedisModule_ZsetScore(RedisModuleKey *key, RedisModuleString *ele, double *s
'ele' and returns REDISMODULE_OK. Otherwise REDISMODULE_ERR is returned
to signal one of the following conditions:
- There is no such element 'ele' in the sorted set.
- The key is not a sorted set.
- The key is an open empty key.
* There is no such element 'ele' in the sorted set.
* The key is not a sorted set.
* The key is an open empty key.
### RedisModule_ZsetRangeStop
@ -1025,8 +1221,8 @@ int RedisModule_HashSet(RedisModuleKey *key, int flags, ...) {
In the following case the return value is always zero:
- The key was not open for writing.
- The key was associated with a non Hash value.
* The key was not open for writing.
* The key was associated with a non Hash value.
### RedisModule_HashGet
@ -1042,8 +1238,8 @@ int RedisModule_HashGet(RedisModuleKey *key, int flags, ...) {
This is an example usage:
RedisModuleString *first, *second;
RedisModule_HashGet(mykey,REDISMODULE_HASH_NONE,argv[1],&first,
RedisModuleString *first, *second;
RedisModule_HashGet(mykey,REDISMODULE_HASH_NONE,argv[1],&first,
argv[2],&second,NULL);
As with RedisModule_HashSet() the behavior of the command can be specified
@ -1058,13 +1254,13 @@ int RedisModule_HashGet(RedisModuleKey *key, int flags, ...) {
Example of REDISMODULE_HASH_CFIELD:
RedisModuleString *username, *hashedpass;
RedisModule_HashGet(mykey,"username",&username,"hp",&hashedpass, NULL);
RedisModuleString *username, *hashedpass;
RedisModule_HashGet(mykey,"username",&username,"hp",&hashedpass, NULL);
Example of REDISMODULE_HASH_EXISTS:
int exists;
RedisModule_HashGet(mykey,argv[1],&exists,NULL);
int exists;
RedisModule_HashGet(mykey,argv[1],&exists,NULL);
The function returns REDISMODULE_OK on success and REDISMODULE_ERR if
the key is not an hash value.
@ -1156,6 +1352,263 @@ const char *RedisModule_CallReplyProto(RedisModuleCallReply *reply, size_t *len)
that returned the reply object.
### RedisModule_CreateDataType
```
moduleType *RedisModule_CreateDataType(RedisModuleCtx *ctx, const char *name, int encver, moduleTypeLoadFunc rdb_load, moduleTypeSaveFunc rdb_save, moduleTypeRewriteFunc aof_rewrite, moduleTypeDigestFunc digest, moduleTypeFreeFunc free) {
```
Register a new data type exported by the module. The parameters are the
following. Please for in depth documentation check the modules API
documentation, especially the INTRO.md file.
* **name**: A 9 characters data type name that MUST be unique in the Redis
Modules ecosystem. Be creative... and there will be no collisions. Use
the charset A-Z a-z 9-0, plus the two "-_" characters. A good
idea is to use, for example `<typename>-<vendor>`. For example
"tree-AntZ" may mean "Tree data structure by @antirez". To use both
lower case and upper case letters helps in order to prevent collisions.
* **encver**: Encoding version, which is, the version of the serialization
that a module used in order to persist data. As long as the "name"
matches, the RDB loading will be dispatched to the type callbacks
whatever 'encver' is used, however the module can understand if
the encoding it must load are of an older version of the module.
For example the module "tree-AntZ" initially used encver=0. Later
after an upgrade, it started to serialize data in a different format
and to register the type with encver=1. However this module may
still load old data produced by an older version if the rdb_load
callback is able to check the encver value and act accordingly.
The encver must be a positive value between 0 and 1023.
* **rdb_load**: A callback function pointer that loads data from RDB files.
* **rdb_save**: A callback function pointer that saves data to RDB files.
* **aof_rewrite**: A callback function pointer that rewrites data as commands.
* **digest**: A callback function pointer that is used for `DEBUG DIGEST`.
* **free**: A callback function pointer that can free a type value.
Note: the module name "AAAAAAAAA" is reserved and produces an error, it
happens to be pretty lame as well.
If there is already a module registering a type with the same name,
and if the module name or encver is invalid, NULL is returned.
Otherwise the new type is registered into Redis, and a reference of
type RedisModuleType is returned: the caller of the function should store
this reference into a gobal variable to make future use of it in the
modules type API, since a single module may register multiple types.
Example code fragment:
static RedisModuleType *BalancedTreeType;
int RedisModule_OnLoad(RedisModuleCtx *ctx) {
// some code here ...
BalancedTreeType = RM_CreateDataType(...);
}
### RedisModule_ModuleTypeSetValue
```
int RedisModule_ModuleTypeSetValue(RedisModuleKey *key, moduleType *mt, void *value) {
```
If the key is open for writing, set the specified module type object
as the value of the key, deleting the old value if any.
On success REDISMODULE_OK is returned. If the key is not open for
writing or there is an active iterator, REDISMODULE_ERR is returned.
### RedisModule_ModuleTypeGetType
```
moduleType *RedisModule_ModuleTypeGetType(RedisModuleKey *key) {
```
Assuming RedisModule_KeyType() returned REDISMODULE_KEYTYPE_MODULE on
the key, returns the moduel type pointer of the value stored at key.
If the key is NULL, is not associated with a module type, or is empty,
then NULL is returned instead.
### RedisModule_ModuleTypeGetValue
```
void *RedisModule_ModuleTypeGetValue(RedisModuleKey *key) {
```
Assuming RedisModule_KeyType() returned REDISMODULE_KEYTYPE_MODULE on
the key, returns the module type low-level value stored at key, as
it was set by the user via RedisModule_ModuleTypeSet().
If the key is NULL, is not associated with a module type, or is empty,
then NULL is returned instead.
### RedisModule_SaveUnsigned
```
void RedisModule_SaveUnsigned(RedisModuleIO *io, uint64_t value) {
```
Save an unsigned 64 bit value into the RDB file. This function should only
be called in the context of the rdb_save method of modules implementing new
data types.
### RedisModule_LoadUnsigned
```
uint64_t RedisModule_LoadUnsigned(RedisModuleIO *io) {
```
Load an unsigned 64 bit value from the RDB file. This function should only
be called in the context of the rdb_load method of modules implementing
new data types.
### RedisModule_SaveSigned
```
void RedisModule_SaveSigned(RedisModuleIO *io, int64_t value) {
```
Like RedisModule_SaveUnsigned() but for signed 64 bit values.
### RedisModule_LoadSigned
```
int64_t RedisModule_LoadSigned(RedisModuleIO *io) {
```
Like RedisModule_LoadUnsigned() but for signed 64 bit values.
### RedisModule_SaveString
```
void RedisModule_SaveString(RedisModuleIO *io, RedisModuleString *s) {
```
In the context of the rdb_save method of a module type, saves a
string into the RDB file taking as input a RedisModuleString.
The string can be later loaded with RedisModule_LoadString() or
other Load family functions expecting a serialized string inside
the RDB file.
### RedisModule_SaveStringBuffer
```
void RedisModule_SaveStringBuffer(RedisModuleIO *io, const char *str, size_t len) {
```
Like RedisModule_SaveString() but takes a raw C pointer and length
as input.
### RedisModule_LoadString
```
RedisModuleString *RedisModule_LoadString(RedisModuleIO *io) {
```
In the context of the rdb_load method of a module data type, loads a string
from the RDB file, that was previously saved with RedisModule_SaveString()
functions family.
The returned string is a newly allocated RedisModuleString object, and
the user should at some point free it with a call to RedisModule_FreeString().
If the data structure does not store strings as RedisModuleString objects,
the similar function RedisModule_LoadStringBuffer() could be used instead.
### RedisModule_LoadStringBuffer
```
char *RedisModule_LoadStringBuffer(RedisModuleIO *io, size_t *lenptr) {
```
Like RedisModule_LoadString() but returns an heap allocated string that
was allocated with RedisModule_Alloc(), and can be resized or freed with
RedisModule_Realloc() or RedisModule_Free().
The size of the string is stored at '*lenptr' if not NULL.
The returned string is not automatically NULL termianted, it is loaded
exactly as it was stored inisde the RDB file.
### RedisModule_SaveDouble
```
void RedisModule_SaveDouble(RedisModuleIO *io, double value) {
```
In the context of the rdb_save method of a module data type, saves a double
value to the RDB file. The double can be a valid number, a NaN or infinity.
It is possible to load back the value with RedisModule_LoadDouble().
### RedisModule_LoadDouble
```
double RedisModule_LoadDouble(RedisModuleIO *io) {
```
In the context of the rdb_save method of a module data type, loads back the
double value saved by RedisModule_SaveDouble().
### RedisModule_SaveFloat
```
void RedisModule_SaveFloat(RedisModuleIO *io, float value) {
```
In the context of the rdb_save method of a module data type, saves a float
value to the RDB file. The float can be a valid number, a NaN or infinity.
It is possible to load back the value with RedisModule_LoadFloat().
### RedisModule_LoadFloat
```
float RedisModule_LoadFloat(RedisModuleIO *io) {
```
In the context of the rdb_save method of a module data type, loads back the
float value saved by RedisModule_SaveFloat().
### RedisModule_EmitAOF
```
void RedisModule_EmitAOF(RedisModuleIO *io, const char *cmdname, const char *fmt, ...) {
```
Emits a command into the AOF during the AOF rewriting process. This function
is only called in the context of the aof_rewrite method of data types exported
by a module. The command works exactly like RedisModule_Call() in the way
the parameters are passed, but it does not return anything as the error
handling is performed by Redis itself.
### RedisModule_GetContextFromIO
```
RedisModuleCtx *RedisModule_GetContextFromIO(RedisModuleIO *io) {
```
--------------------------------------------------------------------------
IO context handling
--------------------------------------------------------------------------
### RedisModule_LogRaw
```
void RedisModule_LogRaw(RedisModule *module, const char *levelstr, const char *fmt, va_list ap) {
```
This is the low level function implementing both:
RM_Log()
RM_LogIOError()
### RedisModule_Log
```
void RedisModule_Log(RedisModuleCtx *ctx, const char *levelstr, const char *fmt, ...) {
```
Produces a log message to the standard Redis log, the format accepts
printf-alike specifiers, while level is a string describing the log
level to use when emitting the log, and must be one of the following:
* "debug"
* "verbose"
* "notice"
* "warning"
If the specified log level is invalid, verbose is used by default.
There is a fixed limit to the length of the log line this function is able
to emit, this limti is not specified but is guaranteed to be more than
a few lines of text.
### RedisModule_LogIOError
```
void RedisModule_LogIOError(RedisModuleIO *io, const char *levelstr, const char *fmt, ...) {
```
Log errors from RDB / AOF serialization callbacks.
This function should be used when a callback is returning a critical
error to the caller since cannot load or save the data for some
critical reason.
### RMUtil_ArgExists
```
int RMUtil_ArgExists(const char *arg, RedisModuleString **argv, int argc, int offset);
@ -1215,6 +1668,13 @@ int RMUtil_StringEquals(RedisModuleString *s1, RedisModuleString *s2);
Return 1 if the two strings are equal. Case *sensitive*
### RMUtil_StringEqualsC
```
int RMUtil_StringEqualsC(RedisModuleString *s1, const char *s2);
```
Return 1 if the string is equal to a C NULL terminated string. Case *sensitive*
### RMUtil_StringToLower
```
void RMUtil_StringToLower(RedisModuleString *s);
@ -1238,6 +1698,13 @@ int Vector_Get(Vector *v, size_t pos, void *ptr);
otherwise 1
### Vector_Pop
```
int Vector_Pop(Vector *v, void *ptr);
```
Get the element at the end of the vector, decreasing the size by one
### Vector_Resize
```
int Vector_Resize(Vector *v, size_t newcap);
@ -1247,14 +1714,14 @@ int Vector_Resize(Vector *v, size_t newcap);
### Vector_Size
```
inline int Vector_Size(Vector *v) { return v->top; }
int Vector_Size(Vector *v);
```
return the used size of the vector, regardless of capacity
### Vector_Cap
```
inline int Vector_Cap(Vector *v) { return v->cap; }
int Vector_Cap(Vector *v);
```
return the actual capacity

Write Preview
Loading…
Cancel
Save