/*
 *
 *  Copyright (c) 2011-2015
 *  name : Francis Banyikwa
 *  email: mhogomchungu@gmail.com
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef STRINGTYPE
#define STRINGTYPE

#ifdef __cplusplus
extern "C" {
#endif

#include <string.h>
#include <sys/types.h>
#include <stdlib.h>
/*
 * Takes a pointer to a function to be called when memory allocation can not take place
 * ie if the system has run out of memory and malloc() or realloc() has failed.
 * This function is optional and "StringVoid" will be returned on memory exaustion if the function
 * isnt set.
 */
void StringExitOnMemoryExaustion( void (*)( void ) ) ;

/*
 * string_t type is a  string handle,all string operation should happen through this handle.
 */
typedef struct StringType * string_t ;

/*
 * create a custom type to represent a string_t pointing to NULL while hiding the pointer nature of string_t
 * string_t is an opaque handle and NULL assignment "gives unnecessary info" about its nature.
 */
#define StringVoid ( ( string_t ) 0 )

typedef char * StringIterator ;

/*
 * Get stl style iterator on the managed string
 */
void StringGetIterators( string_t,StringIterator * begin,StringIterator * end ) ;

/*
 * initialize a handle with a C string
 */
string_t String( const char * cstring ) ;

/*
 * initialize a handle with multiple C strings concatenated together.
 */
string_t String_1( const char * cstring,... ) __attribute__ ( ( sentinel ) ) ;

/*
 * initialize a handle with an empty C string
 */
string_t StringEmpty( void ) ;

/*
 * initialize a handle with a buffer of size s
 */
string_t StringBuffer( size_t s ) ;

/*
 * ininitialize a string handle by memcpy() length characters from a string
 * a NULL character will be appended to the string.
 */
string_t StringWithSize( const char * string,size_t length ) ;

/*
 * Append a string pointer to by s into a string handled by handle st
 *
 * On success,a concatenated string is returned.
 * On error,NULL is returned and the original string remain intact.
 */
const char * StringAppend( string_t st,const  char * s )  ;

/*
 * Append a u_int64_t number to the string
 */
const char * StringAppendInt( string_t,u_int64_t ) ;

/*
 * subsititue all occurance of string str with a number num
 */
const char * StringSubStringWithInt( string_t st,const char * str,u_int64_t num ) ;

/*
 * Append multitple const char * strings to a string handled by handle st.
 * NOTE: The list must be terminated a NULL character.
 * example usage
 *  string_t st = String( "abc" ) ;
 *  StringMultipleAppend( st,"def","ghi",NULL ) ;
 */
const char * StringMultipleAppend( string_t st,... )  __attribute__ ( ( sentinel ) ) ;

/*
 * Append a string handled by xt into a string handled by handle st
 *
 * On success,a concatenated string is returned.
 * On error,NULL is returned and the original string remain intact.
 */
const char * StringAppendString( string_t st,string_t xt )  ;

/*
 * check if a string handled by st has str in it
 * return 1 if str is found
 * return 0 if str is not found
 */
int StringContains( string_t st,const char * str ) ;

/*
 * check if a string handled by st has str in it
 * return 0 if str is found
 * return 1 if str is not found
 */
static __inline__ int StringDoesNotContain( string_t st,const char * str )
{
	return !StringContains( st,str ) ;
}

/*
 * Append multiple string_t to a string handled by handle st .
 * Same requirement as StringMultipleAppend apply
 * NOTE:The series must be NULL terminated.
 */
const char * StringAppendMultipleString( string_t st,... )  __attribute__ ( ( sentinel ) ) ;

/*
 * Append a char c into a string handled by handle st
 *
 * On success,a concatenated string is returned.
 * On error,NULL is returned and the original string remain intact.
 */
const char * StringAppendChar( string_t st,char c )  ;

/*
 * Prepend a string pointed to by s into a string handled by handle st
 *
 * On success,a concatenated string is returned
 * On error,NULL is returned and the original string remain intact
 */
const char * StringPrepend( string_t st,const char * s )  ;

/*
 * prepend multiple const char * to a string handled by string_t st.
 * NOTE: entries will be prepended in the order they are presented
 * NOTE: a list of entries must be NULL terminated
 *  example usage
 *  string_t st = String( "ghi" ) ;
 *  StringMultipleAppend( st,"def","abc",NULL ) ;
 */
const char * StringMultiplePrepend( string_t st,... )   __attribute__ ( ( sentinel ) ) ;

/*
 * prepend multiple string_t to a string handled by string_t st.
 * NOTE: entries will be prepended in the order they are presented
 * NOTE: a list of entries must be NULL terminated
 */
const char * StringMultiplePrependString( string_t st,... )  __attribute__ ( ( sentinel ) ) ;

/*
 * Prepend a string_t xt into a string handled by handle st
 *
 * On success,a concatenated string is returned
 * On error,NULL is returned and the original string remain intact
 */
const char * StringPrependString( string_t st,string_t xt )  ;
/*
 * Prepend a char c into a string handled by handle st
 *
 * On success,a concatenated string is returned
 * On error,NULL is returned and the original string remain intact
 */
const char * StringPrependChar( string_t st,char c )  ;

/*
 * Inherit a string pointed to by data and return a string handle to the string on success or NULL on error.
 * This function should inherit strings only from a dynamically created memory.
 * The original string remains intact when the function error out.
 */
string_t StringInherit( char ** data ) ;

/*
 * Inherit a string of size s pointed to by data and return a string handle to the string on success or NULL on error.
 * This function should inherit strings only from a dynamically created memory.
 * The original string remains intacct when the function error out.
 * size is the size of the string
 * length is the size of the buffer holding the string
 */
string_t StringInheritWithSize( char ** data,size_t size,size_t length ) ;

/*
 * Returns a const pointer to a string handled by handle st.
 * The returned pointer is guaranteed to be valid only if no further operation is performed on the string.
 */
static __inline__ const char * StringContent( string_t st ) ;

/*
 * This function returns a pointer to a string and is guaranteed to be valid as long as StringDelete() is
 * not called on the string.
 *
 * The underlying string can be obtained after the returned double pointer is derefenced.
 */
static __inline__ const char ** StringPointer( string_t st ) ;

/*
 * printf() the string handled by handle st *
 */
void StringPrint( string_t st ) ;

/*
 * printf() the string handled by handle st and followed by a newline
 * it has the same effect as StringPrint() followed by printf("\n")
 */
void StringPrintLine( string_t st ) ;

/*
 * Returns an editable string copy of a string handled by handle st.
 * Remember to free it when you are done using it.
 * NULL is returned when the copy can not be made.
 */
char * StringCopy_1( string_t st ) ;

/*
 * Make a copy of string_t st
 * return NULL on error.
 */
string_t StringCopy( string_t st ) ;

/*
 * returns a copy of a string.
 * remember to free() it when done with it
 */
char * StringCopy_2( const char * ) ;

/*
 * Returns an editable copy of a string made up of upto x characters
 * Remember to free string when you are done with it.
 * returns NULL on error. *
 */
char * StringCopy_3( string_t st,size_t x ) ;

/*
 * Write "size" amount of content of a string handled by "st" to a buffer pointed by "buffer"  *
 */
void StringReadToBuffer( string_t st,char * buffer,size_t size ) ;

/*
 * Remember to clean after yourself.
 * Always call this function when you are done with the string handled by handle st.
 * The function will not attempt to double delete,or delete unassigned handle( NULL handle ),for
 * this to work,make sure your handles are NULL ininitialized.
 * NULL is assigned to handle to invalidate it
 */
void StringDelete( string_t * st );

/*
 * convert all upper case characters to lower case
 */
const char * StringToLowerCase( string_t ) ;

/*
 * clear the string before StringDelete() it
 */
void StringClearDelete( string_t * st ) ;

/*
 * Remember to clean after yourself.
 * delete multitple string_t objects.
 * NOTE: a list of entries must be NULL terminated
 * The function will not attempt to double delete,or delete unassigned handle( NULL handle ),for
 * this to work,make sure your handled are NULL ininitialized.
 * NULL is assigned to each handle to invalidate them
 */
void StringMultipleDelete( string_t * st,... )  __attribute__ ( ( sentinel ) ) ;

/*
 * input argument: String handle
 * return value: a pointer to the string managed by the handle.
 *
 * This function deletes the handle presented through argument st and returns
 * a pointer to the string handled by st.
 *
 * Remember to free the pointer( using free() ) when you are done with it
 *
 * Use this function when you no longer need the handle i.e dont want to do string
 * manipulation through the handle but want the pointer to the string it managed.
 */
char * StringDeleteHandle( string_t * st ) ;

/*
 * Return the length of the string handled by handle st.
 */
size_t StringLength( string_t st ) ;

/*
 * Return 1 if the the length of the string managed by st equals s.
 * Return 0 otherwise.
 */
int StringLengthMatch( string_t st,size_t s ) ;

/*
 * Return a character at position p.First position is at "0".
 *
 * NOTE: it is your responsibility to make sure p is within range
 */
char StringCharAt( string_t st,size_t p ) ;

/*
 * Returns the last character in the string
 */
char StringCharAtLast( string_t st ) ;

/*
 * return the position of the first occurance of character s starting from position p.
 *
 * -1 is returned if the character is not in the string.
 *
 * NOTE: first character in the string is at position 0
 */
ssize_t StringIndexOfChar( string_t st,size_t p,char s ) ;

/*
 * return the position of the first occurance of string s starting from position p.
 *
 * -1 is returned if s isnt in the string
 *
 * NOTE: first character in the string is at position 0
 */
ssize_t StringIndexOfString( string_t st,size_t p,const char * s ) ;

/*
 * Return the position of the last occurance of character s
 *
 * -1 is returned if the character isnt in the string
 */
ssize_t StringLastIndexOfChar( string_t st,char s ) ;

/*
 * Returns the last occurance of a string pointed by s
 *
 * -1 is returned of the string is not found.
 *
 * NOTE: first character in the string is at position 0
 *
 */
ssize_t StringLastIndexOfString( string_t st,const char * s ) ;

/*
 * Return a const string starting at position p. First position is at 0
 *
 * NOTE: it is your responsibility to make sure p is within range.
 */
const char * StringStringAt( string_t st,size_t p ) ;

/*
 * return 1 if a string is a part of stringlist
 * return 0 otherwise or if StringVoid
 */
int StringOwned( string_t ) ;

/*
 * call mlock() on the string
 */
int StringLock( string_t ) ;

/*
 * call munlock() on the string
 */
int StringUnlock( string_t ) ;

/*
 * Check to see if the string pointer by st ends with string s.
 *
 * return 1 is it does
 *
 * return 0 if it doesnt
 */
int StringEndsWith( string_t st,const char * s ) ;

/*
 * Check to see if a string e ends with string s.
 *
 * return 1 is it does
 *
 * return 0 if it doesnt
 */
int StringEndsWith_1( const char * e,const char * s ) ;

/*
 * Check to see if string e ends with atleast one of other arguments.
 *
 * return 1 is it does
 *
 * return 0 if it doesnt
 */
int StringEndsWithAtLeastOne( const char * e,... ) __attribute__ ( ( sentinel ) ) ;

/*
 * Check to see if a string e ends with a string s.
 *
 * return 1 is it does
 *
 * return 0 if it doesnt
 */
int StringEndsWith_2( string_t e,string_t s ) ;

/*
 * check to see if the string handled by handle st starts with a string s
 * return 1 if it does
 * return 0 if it doesnt
 */
int StringStartsWith( string_t st,const char * s ) ;

/*
 * check to see if the string handled by handle st starts with a string handled by handle xt
 * return 1 if it does
 * return 0 if it doesnt
 */
int StringStartsWith_1( string_t st,string_t xt ) ;

/*
 * check if string a starts with string b and ends with string c
 * return 1 if it does
 * return 0 if it doesnt
 */
int StringStartsAndEndsWith( const char * a,const char * b,const char * c ) ;

/*
 * check to see the string_t object starts with atleast one of the arbitrary number of cstrings
 * return 1 if it does
 * return 0 if it does not
 *
 * exampe:
 * st = String( "abcdef" ) ;
 * int r = StringStartsWithAtLeastOne( st,"rrr","www","abc",NULL ) ;
 * r will contain "1" since "abc" argument match the beginning of the string_t object
 * NOTE:The series must be NULL terminated.
 */
int StringStartsWithAtLeastOne( string_t st,... ) __attribute__ ( ( sentinel ) ) ;

/*
 *Check to see if the string pointer by st ends with char s.
 *
 * return 1 is it does
 *
 * return 0 if it doesnt *
 */
int StringEndsWithChar( string_t st,char s ) ;

/*
 * Insert a string s from position x and returns a pointer to the new string
 *
 * on error returns NULL and the original string remains intact
 */
const char * StringInsertString( string_t st,size_t x,const char * s ) ;

/*
 * Insert a char s at position x and returns a pointer to the new string
 *
 * on error returns NULL and the original string remains intact
 */
const char * StringInsertChar( string_t st,size_t x,char s ) ;

/*
 * subsititue whatever character is at position x by character s
 * returns a pointer to the string containing the subsititue
 */
const char * StringSubChar( string_t st,size_t x,char s ) ;

/*
 * start from position x and subsititue all characters in the string by string s.
 * returns a pointer with the substitution.
 */
const char * StringSubString( string_t st,size_t x,const char * s ) ;

/*
 * remove all character after index x and then insert string s at index.
 */
const char * StringAppendAt( string_t st,size_t x,const char * s ) ;

/*
 * start at position x and remove y character(s) going right and returns a pointer
 * to the new string or NULL on error and the original string remain intact.
 * Careful though,make sure you dont delete past the string length
 */
const char * StringRemoveLength( string_t st,size_t x,size_t y ) ;

/*
 * remove all occurances of string s in a string handled by handle st.
 * return a pointer to the resulting string on success and NULL on error and the original string
 * remain intact
 *
 */
const char * StringRemoveString( string_t st,const char * s ) ;

/*
 * starting at position p,remove all occurances of string s in a string handled by handle st.
 * return a pointer to the resulting string on success and NULL on error and the original string
 * remain intact
 *
 */
const char * StringRemoveStringPos( string_t st,const char * s,size_t p ) ;

/*
 * remove the first x characters counting from the right ie,remove the last x characters from the string
 * Returns a pointer to the result,NULL on error and the original string remain intact
 */
const char * StringRemoveRight( string_t st,size_t x ) ;

/*
 * Clear the string by writing '\0' using memset() essentiall wipe out all of its current content.
 * This is a bit more expensive but useful if you want to start afresh with an empty string.
 */
void StringClear( string_t st ) ;

/*
 * forget about all content in the string and start afresh as if the string is not allocated.
 * The old data is still there and will be overwritten by new data as the string get filled up
 */
void StringReset( string_t st ) ;

/*
 * remove the first x characters from the string counting from the left
 * Returns a pointer to the result,NULL on error and the original string remain intact
 */
const char * StringRemoveLeft( string_t st,size_t x ) ;

/*
 * remove all occurances numbers in the string,ie '0','1','2' etc
 */
const char * StringRemoveDigits( string_t ) ;

/*
 * Return a sub string starting at position x and made up of y characters
 *
 * NULL is returned if the operation fail.
 *
 * Remember to free the returned string when done with it. *
 */
string_t StringMidString( string_t st,size_t x,size_t y ) ;

/*
 * replace all occurance of string x by string y
 * return a pointer to the resulting string on success or NULL on error and the original string
 * remain intact.
 */
const char * StringReplaceString( string_t st,const char * x,const char * y ) ;

/*
 * replace the string managed by string_t object by string str
 * return a pointer to the new string managed by string_t object or NULL if either of the argument is NULL
 */
const char * StringReplace( string_t,const char * str ) ;

/*
 * starting at position p,replace all occurance of string x by string y
 * return a pointer to the resulting string on success or NULL on error and the original string
 * remain intact.
 */
const char * StringReplaceStringPos( string_t st,const char * x,const char * y,size_t p ) ;

/*
 * replace all occurance of char x by char y
 * Return a const pointer to a modified string
 */
const char * StringReplaceChar( string_t st,char x,char y ) ;

/*
 * start at index z,replace the first occurance of character x by character y
 * Only the first character will be subsituted if found
 * NULL is returned if substitution could not take place
 * modified string is returned if substitution took place
 */
const char * StringReplaceChar_1( string_t st,size_t z,char x,char y ) ;

/*
 * starting at position p,replace all occurance of char x by char y
 * Return a const pointer to a modified string
 */
const char * StringReplaceCharPos( string_t st,char x,char y,size_t p ) ;

/*
 *  Replace all characters in y by x in a string handled by st
 */
const char * StringReplaceCharString( string_t st,char x,const char * y ) ;

/*
 * Starting at position,Replace all characters in y by x in a string handled by st
 */
const char * StringReplaceCharStringPos( string_t st,char x,const char * y,size_t p ) ;

/*
 * convert a number z into a string and store the result into array x of size y.
 *
 * return value: a pointer to the beginning of the result(use this pointer and not x).
 *
 * NOTE: Its your responsibility to make sure the resulting string fit into array x.
 * If z has N digits,then the array must be atleast N+1 in size,null character
 * takes the last spot.
 */

char * StringIntToString_1( char * x,size_t y,u_int64_t z ) ;

/*
 * convert a number z into a string
 */
string_t StringIntToString( u_int64_t ) ;

/*
 * convert a string made up of digits to a u_int64_t value
 * eg:
 * u_int64_t x = StringConvertToInt( "43542" ) ;
 */
u_int64_t StringConvertToInt( const char * ) ;

/*
 * Compare a string handled by handle x to a string handled by handle y.
 * return 1 if they are equal
 * return 0 if they are not equal
 */
int StringsAreEqual_1( string_t x,string_t y ) ;

/*
 * Compare a string handled by handle x to a string pointer to by y.
 * return 1 if they are equal
 * return 0 if they are not equal
 */
int StringsAreEqual_2( string_t x,const char * y ) ;

/*
 * return 1 if x holds an empty string
 * return 0 if x holds a non empty string
 * return 0 if x is StringVoid
 */
int StringIsEmpty( string_t x ) ;

/*
 * Compare a string handled by handle x to a string pointer to by y.
 * return 0 if they are equal
 * return 1 if they are not equal
 */
static __inline__ int StringsAreNotEqual_2( string_t x,const char * y )
{
	return !StringsAreEqual_2( x,y ) ;
}

/*
 * compare string managed by x with a series of cstrings and return true if atleast one of them match
 * NOTE:the series of strings must be NULL terminated
 * eg.
 * string_t st = String( "abc" ) ;
 * int equal = StringMatchOneAtLeastOne( st,"def","ugf",NULL ) ;
 */
int StringAtLeastOneMatch( string_t x,... )  __attribute__ ( ( sentinel ) ) ;

/*
 * compare cstring x with a series of cstrings and return true if atleast one of them match
 * NOTE:the series of strings must be NULL terminated
 * eg.
 * int equal = StringMatchOneAtLeastOne_1( "def","ugf","rrt",NULL ) ;
 */
int StringAtLeastOneMatch_1( const char * x,... )  __attribute__ ( ( sentinel ) ) ;

/*
 * Insert character x infront of every character that appear in string y in a string handled by handle st.
 * Retun a poiter to the final string on success and NULL on error and the original string remain intact
 */
const char * StringInsertCharString( string_t st,char x,const char * y ) ;

/*
 * Starting at position p,insert character x infront of every character that appear in string y in a string handled by handle st.
 * Retun a poiter to the final string on success and NULL on error and the original string remain intact
 */
const char * StringInsertCharStringPos( string_t st,char x,const char * y,size_t p ) ;

/*
 * Insert character x infront of every character y in a string handled by handle st.
 * Retun a poiter to the final string on success and NULL on error and the original string remain intact
 */
const char * StringInsertCharChar( string_t st,char x,char y ) ;

/*
 * Crop off the first x elements and the last y elements from the string handled by handle st
 *
 * Return a pointer to the cropped string on success and NULL on error and the original string remain intact.
 * NULL is also returned if cropping will result in less that zero characters in the string
 */
const char * StringCrop( string_t st,size_t x,size_t y ) ;

/*
 * getchar() until a newline or EOF character is reached and put the characters to a string_t object
 * The function basically get its content from the terminal ( stdin ) .
 * NULL is returned if sufficient memory can not be optained to hold terminal content.
 */
string_t StringGetFromTerminal( void ) ;

/*
 * getchar() of upto s characters or until a newline or EOF character is reached and put the characters to a string_t object
 * The function basically get its content from the terminal ( stdin ) .
 * NULL is returned if sufficient memory can not be optained to hold terminal content.
 */
string_t StringGetFromTerminal_1( size_t s ) ;

/*
 * Turn echo off and get string from the terminal.
 * This function is ideal for reading passphrases from the terminal.
 * 1 is returned when character echoing can not be turned off.
 * 2 is returned if sufficient memory can not be optained to hold terminal content.
 * 0 is returned on success.
 */
int StringSilentlyGetFromTerminal( string_t * ) ;

/*
 * Turn echo off and get a string of upto s characters from the terminal.
 * This function is ideal for reading passphrases from the terminal.
 * 1 is returned when character echoing can not be turned off.
 * 2 is returned if sufficient memory can not be optained to hold terminal content.
 * 0 is returned on success.
 */
int StringSilentlyGetFromTerminal_1( string_t *,size_t s ) ;

/*
 *  Open a file given by path and return a string_t handle
 *
 *  NULL is returned if the file could not be opened for reading or could not get sufficient memory to hold the file.
 */
string_t StringGetFromFile( const char * path ) ;

/*
 * constract a string_t object with size random characters read from "/dev/urandom.
 * StringVoid is returned on error.
 */
string_t StringRandomString( size_t size ) ;

/*
 *  Open a file given by path and return a string_t handle through agrument st with the content of the file .
 *  return value: 0 - opefation succeeded.
 *                1 - path is invalid.
 *                2 - could not open file for reading.
 * 		  3 - could not allocate memory to host file content
 */
int StringGetFromFile_1( string_t * st,const char * path ) ;

/*
 *  Open a file given by path and return a string_t handle through agrument st with the content of the file .
 *  Start reading the file from offset byte and read length bytes.
 *  return value: 0 - opefation succeeded.
 *                1 - path is invalid.
 *                2 - could not open file for reading.
 * 		  3 - could not allocate memory to host file content
 */
int StringGetFromFile_3( string_t * st,const char * path,size_t offset,size_t length ) ;

/*
 *  Open a file given by path and return a string_t handle with hhe content of the file .
 *  return value through status:
 *                0 - opefation succeeded.
 *                1 - path is invalid.
 *                2 - could not open file for reading.
 * 		  3 - could not allocate memory to host file content
 *
 * This function does the same thing the previous one does,the different is how return values are returned.
 */
string_t StringGetFromFile_2( const char * path,int * status ) ;

/*
 * reads a maximum of "length" bytes from a file given by "path" argument starting at "offset" offset
 * and then lock the memory buffer.
 * return values:
 * 0 - success
 * 1 - file operation failed
 * 2 - memory operation failed
 *
 * The mlock()ed string object will be returned through str argument
 * negative value of length means reads the entire file content
 *
 * warning memory may or may not lock
 */
int StringGetFromFileMemoryLocked( string_t * str,const char * path,size_t offset,ssize_t length ) ;

/*
 *  White the string managed by handle st to a file given by path and return the number of bytes written. *
 */

#define CREATE 1  /*if the file does not exist,create it,if the file exist,trancate it*/
#define APPEND 2  /* if the file exist,append it*/
void StringWriteToFile( string_t st,const char * path,int mode ) ;

/*
 * Open a virtual file given by path return a string_t handle with the content of the file.
 * Virtual files are like those in /proc,you cab read stuff from them but their sizes are always zero
 */
string_t StringGetFromVirtualFile( const char * path ) ;

/*
 * below two functions creates a hash of the string using junkin's one at a time hash algorithm
 */
u_int32_t StringJenkinsOneAtATimeHash( const char * key ) ;

u_int32_t StringJenkinsOneAtATimeHash_1( string_t ) ;

/*
 * a few convenient "safe" functions
 */

/*
 * why doesnt free() take const void * ????
 */
static __inline__ void StringFree( const void * str )
{
	free( ( void * )str ) ;
}

/*
 * safely do free( *dev ) followed by *dev = NULL
 * this function hence should take only a double pointer.
 * ie
 * char * e = malloc(sizeof(char)) ;
 * ..;
 * StringFree_1(&e);
 */
static __inline__ void StringFree_1( const void * str )
{
	char ** c ;
	if( str != NULL ){
		c = ( char ** ) str ;
		free( *c ) ;
		*c = NULL ;
	}
}

static __inline__ size_t StringSize( const char * str )
{
	if( str == NULL ){
		return 0 ;
	}else{
		return strlen( str ) ;
	}
}

static __inline__ int StringsAreEqual( const char * x,const char * y )
{
	if( x == NULL || y == NULL ){
		return 0 ;
	}else{
		return strcmp( x,y ) == 0 ;
	}
}

static __inline__ int StringHasNothing( const char * x )
{
	return x != NULL && *x == '\0' ;
}

static __inline__ int StringsAreNotEqual( const char * x,const char * y )
{
	if( x == NULL || y == NULL ){
		return 1 ;
	}else{
		return strcmp( x,y ) != 0 ;
	}
}

static __inline__ int StringPrefixMatch( const char * x,const char * y,size_t z )
{
	if( x == NULL || y == NULL ){
		return 0 ;
	}else{
		return strncmp( x,y,z ) == 0 ;
	}
}

/*
 * returns true if a atleast one cstring in the series starts with x
 * NOTE:The series must be NULL terminated.
 */
int StringAtLeastOnePrefixMatch( const char * x,... )  __attribute__ ( ( sentinel ) ) ;

/*
 * returns true if atleast one cstring is a component of x
 * NOTE:The series must be NULL terminated.
 */
int StringHasAtLeastOneComponent_1( const char * x,... ) __attribute__ ( ( sentinel ) ) ;

/*
 * returns true if atleast one cstring is a component of a string managed by object st
 * NOTE:The series must be NULL terminated.
 */
int StringHasAtLeastOneComponent( string_t st,... ) __attribute__ ( ( sentinel ) ) ;

static __inline__ int StringPrefixEqual( const char * x,const char * y )
{
	if( x == NULL || y == NULL ){
		return 0 ;
	}else{
		return strncmp( x,y,strlen( y ) ) == 0 ;
	}
}

static __inline__ int StringPrefixNotEqual( const char * x,const char * y )
{
	if( x == NULL || y == NULL ){
		return 0 ;
	}else{
		return strncmp( x,y,strlen( y ) ) != 0 ;
	}
}

static __inline__ ssize_t StringHasComponent_1( const char * x,const char * y )
{
	char * e ;
	if( x == NULL || y == NULL ){
		return -1 ;
	}else{
		e = strstr( x,y ) ;
		if( e == NULL ){
			return -1 ;
		}else{
			return e - x ;
		}
	}
}

static __inline__ size_t StringCharCount( const char * x,char y )
{
	size_t s = 0 ;
	char m ;

	if( x != NULL ){

		while( 1 ){

			m = *x ;
			x++ ;

			if( m == y ){

				s++ ;

			}else if( m == '\0' ){

				break ;
			}
		}
	}

	return s ;
}

static __inline__ int StringHasComponent( const char * x,const char * y )
{
	if( x == NULL || y == NULL ){
		return 0 ;
	}else{
		return strstr( x,y ) != NULL ;
	}
}

static __inline__ int StringHasNoComponent( const char * x,const char * y )
{
	if( x == NULL || y == NULL ){
		return 0 ;
	}else{
		return strstr( x,y ) == NULL ;
	}
}

static __inline__ ssize_t StringLastIndexOfChar_1( const char * str,char s )
{
	const char * c ;
	if( str == NULL ){
		return -1 ;
	}else{
		c = strrchr( str,s ) ;
		if( c == NULL ){
			return -1 ;
		}else{
			return c - str ;
		}
	}
}

static __inline__ ssize_t StringFirstIndexOfChar_1( const char * str,char s )
{
	if( str == NULL ){
		return -1 ;
	}else{
		return strchr( str,s ) - str ;
	}
}

static __inline__ const char ** StringPointer( string_t st )
{
	return ( const char ** ) st ;
}

static __inline__ const char * StringContent( string_t st )
{
	const char ** e = StringPointer( st ) ;

	if( e == NULL ){
		return NULL ;
	}else{
		return *e ;
	}
}

#ifdef __cplusplus
}
#endif

#endif