/**
@return La versin de functions con la que hemos linkado nuestra aplicacion.
*/
- static std::string getVersion() throw();
+ static std::string getVersion() ;
/**
@return Un literal con la arquitectura sobre la que hemos compilado nuestra aplicacion.
*/
- static std::string getArchitecture() throw();
+ static std::string getArchitecture() ;
/**
Indica el número de bits de un entero.
\param number Numero a convertir.
@return Un literal con el numero convertido a cadena decimal.
*/
- static std::string asString(const int number) throw();
+ static std::string asString(const int number) ;
/**
\param number Numero a convertir.
@return Un literal con el numero sin signo convertido a cadena decimal.
*/
- static std::string asString(const unsigned int number) throw();
+ static std::string asString(const unsigned int number) ;
/**
Devuelve un literal con tel numero convertido a cadena decimal
@return Un literal con el numero signo convertido a cadena decimal.
*/
- static std::string asString(const S64 number) throw();
+ static std::string asString(const S64 number) ;
/**
Devuelve un literal con tel numero convertido a cadena decimal
@return Un literal con el numero signo convertido a cadena decimal.
*/
- static std::string asString(const U64 number) throw();
+ static std::string asString(const U64 number) ;
/**
\param _bool Booleano a convertir.
\return Un literal con el boolean convertido a cadena.
*/
- static const char* asString(const bool _bool) throw() { return (_bool == true) ? "true" : "false"; }
+ static const char* asString(const bool _bool) { return (_bool == true) ? "true" : "false"; }
/**
Devuelve una cadena con el bloque de datos decodificado en grupos de 16 bytes.
\param characterByLine Número de caracteres en cada línea.
@return Devuelve una cadena con el bloque de datos decodificado en grupos de 16 bytes.
*/
- static std::string asString(const DataBlock& dataBlock, const int characterByLine = 16) throw();
+ static std::string asString(const DataBlock& dataBlock, const int characterByLine = 16) ;
/**
Devuelve una cadena con el numero en coma flotante.
\param format Formato aplicado para convertir el numero a cadena. Ver \em man printf.
\return una cadena con el numero en coma flotante.
*/
- static std::string asString(const double v, const char* format = "%e") throw();
+ static std::string asString(const double v, const char* format = "%e") ;
/**
Devuelve una cadena con el numero en coma flotante.
\param format Formato aplicado para convertir el numero a cadena. Ver \em man printf.
\return una cadena con el numero en coma flotante.
*/
- static std::string asString(const float v, const char* format = "%f") throw();
+ static std::string asString(const float v, const char* format = "%f") ;
/**
\param comment Comentario que precede al valor.
@return Un literal con el numero convertido a cadena decimal.
*/
static std::string asText(const char* comment, const int number)
- throw() {
+ {
std::string result(comment);
return result += asString(number);
}
@return Un literal con el numero convertido a cadena decimal.
*/
static std::string asText(const char* comment, const S64 number)
- throw() {
+ {
std::string result(comment);
return result += asString(number);
}
@return Un literal con el numero convertido a cadena decimal.
*/
static std::string asText(const char* comment, const bool _bool)
- throw() {
+ {
std::string result(comment);
return result += asString(_bool);
}
@return Un literal con el numero convertido a cadena decimal.
*/
static std::string asText(const char* comment, const DataBlock& dataBlock, const int characterByLine = 16)
- throw() {
+ {
std::string result(comment);
return result += asString(dataBlock, characterByLine);
}
\return Un literal con el numero convertido a cadena.
*/
static std::string asText(const char* comment, const float value, const char* format = "%f")
- throw() {
+ {
std::string result(comment);
return result += asString(value, format);
}
\return Un literal con el numero convertido a cadena.
*/
static std::string asText(const char* comment, const double value, const char* format = "%e")
- throw() {
+ {
std::string result(comment);
return result += asString(value, format);
}
\param number Numero a convertir.
@return Un literal con el numero convertido a cadena hexadecimal.
*/
- static std::string asHexString(const int number) throw();
+ static std::string asHexString(const int number) ;
/**
\param number Numero a convertir.
@return Un literal con el numero convertido a cadena hexadecimal.
*/
- static std::string asHexString(const S64 number) throw();
+ static std::string asHexString(const S64 number) ;
/**
\param number Numero a convertir.
@return Un literal con el numero convertido a cadena hexadecimal.
*/
- static std::string asHexString(const U64 number) throw() { return asHexString((S64) number); }
+ static std::string asHexString(const U64 number) { return asHexString((S64) number); }
/**
\param comment Comentario que precede al valor.
@return Un literal con el numero convertido a cadena decimal.
*/
static std::string asHexText(const char* comment, const int number)
- throw() {
+ {
std::string result(comment);
return result += asHexString(number);
}
@return Un literal con el numero convertido a cadena decimal.
*/
static std::string asHexText(const char* comment, const S64 number)
- throw() {
+ {
std::string result(comment);
return result += asHexString(number);
}
* \param dataBlock Bloque a codificar.
* \return La cadena que contiene el valor literal del buffer de datos.
*/
- static std::string asHexString(const DataBlock& dataBlock) throw();
+ static std::string asHexString(const DataBlock& dataBlock) ;
/**
* Obtiene el valor original de una cadena obtenido con #asHexString (const DataBlock&).
* \param target Bloque de datos sobre el que decodificar la cadena.
* \return El bloque de datos original correspondiente a la cadena recibida.
*/
- static DataBlock& fromHexString(const std::string& hexString, DataBlock& target) throw(RuntimeException);
+ static DataBlock& fromHexString(const std::string& hexString, DataBlock& target) noexcept(false);
/**
Devuelve una cadena con la hora en formato 'dd/mm/yyyy hh:mm:ss'.
@return Un literal con la hora en el formato 'dd/mm/yyyy hh:mm:ss'.
*/
- static std::string asDateTime(const Second &second) throw();
+ static std::string asDateTime(const Second &second) ;
/**
Devuelve una cadena con la hora en formato 'dd/mm/yyyy hh:mm:ss'.
@return El puntero recibido como parametro conteniendo el literal con la hora
en el formato 'dd/mm/yyyy hh:mm:ss'.
*/
- static const char* asDateTime(const Second &second, char* result) throw();
+ static const char* asDateTime(const Second &second, char* result) ;
/**
Calcula la funcion hash de la cadena recibida como parametro.
\param str Cadena a la que aplicar la funcion hash.
*/
- static S64 hash(const char* str) throw();
+ static S64 hash(const char* str) ;
/**
Calcula la funcion hash de la cadena recibida como parametro.
\param str Cadena a la que aplicar la funcion hash.
*/
- static S64 hash(const std::string& str) throw() { return hash(str.c_str()); }
+ static S64 hash(const std::string& str) { return hash(str.c_str()); }
/**
Devuelve la cadena que contiene el resultado de aplicar la especificacion \em format
\return la cadena que contiene el resultado de aplicar la especificacion \em format
sobre el resto de los parametros.
*/
- static std::string asString(const char* format, ...) throw();
+ static std::string asString(const char* format, ...) ;
/**
Devuelve el resultado de invocar a metodo asString de la clase recibida como parametro.
\return el resultado de invoca a T::asString () si t es distinto de NULL.
\warning La clase T debe tener un metodo estatico con la signatura:
\code
- static const char* className () throw ();
+ static const char* className () ;
\endcode
*/
template <typename T> static std::string asString(const T* t)
- throw() {
+ {
if(t == NULL) {
std::string result(T::className());
result += " { <null> }";
\param str Instancia de la cadena.
\return La misma instancia recibida como parametro.
*/
- static const std::string& asString(const std::string& str) throw() { return str; }
+ static const std::string& asString(const std::string& str) { return str; }
/**
Detiene la ejecucion del thread durante el numero de milisegundos indicados.
\param millisecond Numero de milisegundos que vamos a detener la ejecucion de este thread.
*/
- static void sleep(const Millisecond &millisecond) throw();
+ static void sleep(const Millisecond &millisecond) ;
/**
Obtiene el numero de segundos transcurridos desde el 1 del 1 de 1970.
\return El numero de segundos transcurridos desde el 1 del 1 de 1970.
*/
- static Second second() throw() {
+ static Second second() {
Second result(::time(NULL));
return result;
}
Obtiene el numero de microsegundos transcurridos desde el 1 del 1 de 1970.
\return El numero de microsegundos transcurridos desde el 1 del 1 de 1970.
*/
- static Microsecond microsecond() throw() {
+ static Microsecond microsecond() {
struct timeval tv;
gettimeofday(&tv, NULL);
Microsecond result((Microsecond::type_t)1000000 * tv.tv_sec + tv.tv_usec);
Obtiene el numero de milisegundos transcurridos desde el 1 del 1 de 1970.
\return El numero de milisegundos transcurridos desde el 1 del 1 de 1970.
*/
- static Millisecond millisecond() throw() {
+ static Millisecond millisecond() {
struct timeval tv;
gettimeofday(&tv, NULL);
Millisecond result((Millisecond::type_t)1000 * tv.tv_sec + tv.tv_usec / 1000);
Devuelve la referencia interna de los microsegundos transcurrido en el procesador.
\return la referencia interna de los microsegundos transcurrido en el procesador.
*/
- static Microsecond hardwareClock() throw() {
+ static Microsecond hardwareClock() {
timespec ts;
//clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts); // DONT works (original)
//clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts); // DONT works
\return El valor booleano correspondiente a la cadena recibida.
*/
- static bool asBool(const char* str) throw(RuntimeException);
+ static bool asBool(const char* str) noexcept(false);
/**
Interpreta la cadena recibida como parametro como un entero de 32 bits.
\return
*/
- static int asInteger(const char* str) throw() { return atoi(str); }
+ static int asInteger(const char* str) { return atoi(str); }
/**
Interpreta la cadena recibida como parametro como un entero de 32 bits.
\return
*/
- static S64 asInteger64(const char* str) throw();
+ static S64 asInteger64(const char* str) ;
/**
Devuelve el identificador de thread desde el que es invocado este metodo.
Si el programa no tuviera soporta para MT siempre devolvera 0.
\return el identificador de thread desde el que es invocado este metodo.
*/
- static pthread_t getCurrentThread() throw();
+ static pthread_t getCurrentThread() ;
/**
Devuelve \em true si la version de nucleo que estamos ejecutado soporta multithread o \em false en otro
caso.
\return \em true si la version de nucleo que estamos ejecutado soporta multithread o \em false en otro
*/
- static bool supportMultithread() throw() {
+ static bool supportMultithread() {
WHEN_SINGLETHREAD(return false);
WHEN_MULTITHREAD(return true);
}
\see regexec para mas informacion sobre las expresiones regulares.
*/
- static bool isLike(const char* pattern, const std::string& value) throw(RuntimeException);
+ static bool isLike(const char* pattern, const std::string& value) noexcept(false);
/**
* Devuelve el número de bits necesarios para representar el valor recibido como parámetro.
* \param n Valor a estudiar.
* \return el número de bits necesarios para representar el valor recibido como parámetro.
*/
- static int bitsize(const int n) throw() { return (n == 0) ? 1 : functions::log2(n) + 1; }
+ static int bitsize(const int n) { return (n == 0) ? 1 : functions::log2(n) + 1; }
/**
* Devuelve el número de bits necesarios para representar el valor recibido como parámetro.
* \param n Valor a estudiar.
* \return el número de bits necesarios para representar el valor recibido como parámetro.
*/
- static int bitsize(const S64 n) throw() {
+ static int bitsize(const S64 n) {
int aux = n >> intBitSize;
return (aux != 0) ? (bitsize(aux) + intBitSize) : bitsize((int) n);
}
* \param bitShift Número de bits a desplazar.
* \param n2 Número a combinar con el resultado de la operación (n1 << bitShift).
*/
- static S64 merge(const char* whatis, const int n1, const int n2, const int bitShift) throw(RuntimeException);
+ static S64 merge(const char* whatis, const int n1, const int n2, const int bitShift) noexcept(false);
/**
* Calcula el logaritmo en base 2 del número recibo como parámetro.
* \param v Valor a calcular.
* \return El algoritmo en base 2 del número recibido como parámetro o -1 si el parámetro recibido es 0.
*/
- static int log2(const unsigned int v) throw();
+ static int log2(const unsigned int v) ;
@return Coherent literal as '%d <singular word/plural word>'
*/
- static std::string entriesAsString(int number, const char * wordForSingular = NULL, const char * wordForPlural = NULL) throw();
+ static std::string entriesAsString(int number, const char * wordForSingular = NULL, const char * wordForPlural = NULL) ;
/**
Justify text (traces and output improvement)
@return Processed text
*/
- static std::string justify(const std::string & title, TextJustifyMode::_v mode = TextJustifyMode::Left, char filler = ' ') throw();
+ static std::string justify(const std::string & title, TextJustifyMode::_v mode = TextJustifyMode::Left, char filler = ' ') ;
/**
Highligth text (traces and output improvement)
@return Processed text
*/
- static std::string highlight(const std::string & title, TextHighlightMode::_v mode = TextHighlightMode::Underline, char filler = '-', bool appendCR = true) throw();
+ static std::string highlight(const std::string & title, TextHighlightMode::_v mode = TextHighlightMode::Underline, char filler = '-', bool appendCR = true) ;
/**
Highligth and justify text (traces and output improvement)
@return Processed text
*/
- static std::string highlightJustify(const std::string & title, TextHighlightMode::_v hMode = TextHighlightMode::OverAndUnderline, TextJustifyMode::_v jMode = TextJustifyMode::Center, char highlightFiller = '=', char justifyFiller = ' ', bool appendCR = true) throw() {
+ static std::string highlightJustify(const std::string & title, TextHighlightMode::_v hMode = TextHighlightMode::OverAndUnderline, TextJustifyMode::_v jMode = TextJustifyMode::Center, char highlightFiller = '=', char justifyFiller = ' ', bool appendCR = true) {
return(highlight(justify(title, jMode, justifyFiller), hMode, highlightFiller, appendCR));
}
@param text Text processed
@param tabSpaces Tab spaces (three by default)
*/
- static std::string tab(const std::string & text, int tabSpaces = 3) throw();
+ static std::string tab(const std::string & text, int tabSpaces = 3) ;
//////////////////////////////////////////////////////////////////////////////////////////////////
\see Component
*/
template <typename T> static T* componentByName(const char *className, const char* fromFile, const int fromLine)
- throw(RuntimeException) {
+ noexcept(false) {
ComponentManager &cm = ComponentManager::instantiate();
T* result = static_cast <T*>(cm.find(className));
\return Component instance for the class provided at the pattern
\warning T class must implement a method in the form:
\code
- static const char* getClassName () throw ();
+ static const char* getClassName () ;
\endcode
\see Component
*/
template <typename T> static T* component(const char* fromFile, const int fromLine)
- throw(RuntimeException) {
+ noexcept(false) {
return functions::componentByName<T> (T::getClassName(), fromFile, fromLine);
}
@return Boolean about ocurrency
*/
- static bool endsWith(const std::string & pattern, const std::string & suffix) throw() {
+ static bool endsWith(const std::string & pattern, const std::string & suffix) {
std::string dummy;
return endsWith(pattern, suffix, dummy);
}
/**
Similar to #endsWith but returning additional preffix string by reference (pattern without suffix)
*/
- static bool endsWith(const std::string & pattern, const std::string & suffix, std::string & preffix) throw();
+ static bool endsWith(const std::string & pattern, const std::string & suffix, std::string & preffix) ;
/**
Finds string at the begining of another
@return Boolean about ocurrency
*/
- static bool startsWith(const std::string & pattern, const std::string & preffix) throw() {
+ static bool startsWith(const std::string & pattern, const std::string & preffix) {
std::string dummy;
return startsWith(pattern, preffix, dummy);
}
/**
Similar to #startsWith but returning additional suffix string by reference (pattern without preffix)
*/
- static bool startsWith(const std::string & pattern, const std::string & preffix, std::string & suffix) throw();
+ static bool startsWith(const std::string & pattern, const std::string & preffix, std::string & suffix) ;
/**
Finds 'item' and replaces it with 'target' within the string provided ('text').
@return Modified string
*/
- static std::string replace(const std::string & text, const char *item, const char *target, bool all = true) throw();
+ static std::string replace(const std::string & text, const char *item, const char *target, bool all = true) ;
/**
* Coverts original string without quotation into quoted one: '\%s'
*/
- static std::string addQuotationMarks(const std::string & str) throw();
- static std::string addQuotationMarks(const char * str) throw();
- static std::string addQuotationMarks(const int & integer) throw();
+ static std::string addQuotationMarks(const std::string & str) ;
+ static std::string addQuotationMarks(const char * str) ;
+ static std::string addQuotationMarks(const int & integer) ;
/**
* Generates space-separated string lists based on integer elements
* Also, another separator could be used.
*/
- static std::string vectorToStringRepresentation(const std::vector<int> & v, const char separator = ' ') throw();
+ static std::string vectorToStringRepresentation(const std::vector<int> & v, const char separator = ' ') ;
/**
* Generates space-separated string lists based on string elements.
* Also, another separator could be used.
*/
- static std::string vectorToStringRepresentation(const std::vector<std::string> & v, const char separator = ' ') throw();
+ static std::string vectorToStringRepresentation(const std::vector<std::string> & v, const char separator = ' ') ;
/**
Returns socket notation 'Address:Port'
*/
- static std::string socketLiteralAsString(const std::string & address, int port) throw();
+ static std::string socketLiteralAsString(const std::string & address, int port) ;
/**
Ascii string for buffer/size data block
@return Ascii string representation, and dots for non-printable cheracters
*/
- static std::string asAsciiString(const char * buffer, int size, bool & isFullyPrintable) throw();
+ static std::string asAsciiString(const char * buffer, int size, bool & isFullyPrintable) ;
/**
Same as #asAsciiString but without interest about if is printable or not
*/
- static std::string asAsciiString(const char * buffer, int size) throw() {
+ static std::string asAsciiString(const char * buffer, int size) {
bool isFullyPrintable;
return asAsciiString(buffer, size, isFullyPrintable);
}
/**
Same as #asAsciiString providing anna::DataBlock
*/
- static std::string asAsciiString(const DataBlock & db, bool & isFullyPrintable) throw() {
+ static std::string asAsciiString(const DataBlock & db, bool & isFullyPrintable) {
return asAsciiString(db.getData(), db.getSize(), isFullyPrintable);
}
/**
Same as #asAsciiString providing DataBlock and without interest about if is printable or not
*/
- static std::string asAsciiString(const DataBlock & db) throw() {
+ static std::string asAsciiString(const DataBlock & db) {
bool isFullyPrintable;
return asAsciiString(db.getData(), db.getSize(), isFullyPrintable);
}
*
* @return Encoded DataBlock
*/
- static DataBlock rawIpPresentationAsRaw(const std::string & rawPresentation) throw(RuntimeException);
+ static DataBlock rawIpPresentationAsRaw(const std::string & rawPresentation) noexcept(false);
/**
*
* @return Decoded IP address
*/
- static std::string rawIpPresentationToIpAsString(const std::string & rawPresentation, bool normalize = false) throw(RuntimeException) {
+ static std::string rawIpPresentationToIpAsString(const std::string & rawPresentation, bool normalize = false) noexcept(false) {
return rawIpAsString(rawIpPresentationAsRaw(rawPresentation), normalize);
}
*
* @return Human-readable raw IP presentation
*/
- static std::string rawIpAsRawIpPresentation(const DataBlock & db) throw(RuntimeException);
+ static std::string rawIpAsRawIpPresentation(const DataBlock & db) noexcept(false);
/**
*
* @return Hostname
*/
- static std::string getHostname() throw();
+ static std::string getHostname() ;
/**
* Gets the domain name
*
* @return Domainname
*/
- static std::string getDomainname() throw();
+ static std::string getDomainname() ;
/**
* Gets the FQDN (Fully Qualified Domain Name)
*
* @return FQDN (<hostname>.<domainname>)
*/
- static std::string getFQDN(const char *hostname = NULL, const char *domainname = NULL) throw();
+ static std::string getFQDN(const char *hostname = NULL, const char *domainname = NULL) ;
/**
* Gets the IP based on hostname (#getHostname)
*
* @return Hostname-based IP
*/
- static std::string getHostnameIP() throw();
+ static std::string getHostnameIP() ;
*
* @return Boolean for IPv4 nature
*/
- static bool isIPv4(const std::string & ip, IPv4Type::_v ipv4Type = IPv4Type::Estrict) throw();
+ static bool isIPv4(const std::string & ip, IPv4Type::_v ipv4Type = IPv4Type::Estrict) ;
/**
* IPv6 address family detection
*
* @return Boolean for IPv6 nature
*/
- static bool isIPv6(const std::string & ip) throw();
+ static bool isIPv6(const std::string & ip) ;
/**
* Convert an IPv4 address to IPv6. Also removes dots from IPv4-mapped format.
*
* @return string IPv6 formatted address or launch exception if invalid input
*/
- static std::string IPv4To6(const std::string & ipv4) throw(RuntimeException);
+ static std::string IPv4To6(const std::string & ipv4) noexcept(false);
/**
* Normalizes an IP address to long notation. Specially used for IPv6, but valid for IPv4 (via IPv4To6 conversion).
*
* @return Normalized IP address
*/
- static std::string normalizeIP(const std::string & ip) throw(RuntimeException);
+ static std::string normalizeIP(const std::string & ip) noexcept(false);
/**
* Compare two IP addresses by mean normalization
*
* @return Boolean about IP's comparison
*/
- static bool sameIP(const std::string & ip1, const std::string & ip2) throw(RuntimeException);
+ static bool sameIP(const std::string & ip1, const std::string & ip2) noexcept(false);
/**
* Compare two IP addresses by mean internal comparison after ipv6 preffix restriction
*
* @return Boolean about subnet matching
*/
- static bool matchIPv6(const std::string & ipv6, const std::string & preffixedIpv6) throw(RuntimeException);
+ static bool matchIPv6(const std::string & ipv6, const std::string & preffixedIpv6) noexcept(false);
/**
* IP Address serialization
*
* @return Encoded DataBlock
*/
- static DataBlock ipAsRaw(const std::string & ip) throw(RuntimeException);
+ static DataBlock ipAsRaw(const std::string & ip) noexcept(false);
/**
* IP Address decoding
*
* @return Decoded IP address
*/
- static std::string rawIpAsString(const DataBlock & db, bool normalize = false) throw(RuntimeException) {
+ static std::string rawIpAsString(const DataBlock & db, bool normalize = false) noexcept(false) {
return (rawIpAsString(db.getData(), db.getSize(), normalize));
}
*
* @return Decoded IP address
*/
- static std::string rawIpAsString(const char *buffer, int bufferLength, bool normalize = false) throw(RuntimeException);
+ static std::string rawIpAsString(const char *buffer, int bufferLength, bool normalize = false) noexcept(false);
/**
* Abbreviates an IP address. Specially used for IPv6, but valid for IPv4.
*
* @return Abbreviated IP address
*/
- static std::string abbreviateIP(const std::string & ip) throw(RuntimeException) {
+ static std::string abbreviateIP(const std::string & ip) noexcept(false) {
return (rawIpAsString(ipAsRaw(ip)));
}
* @param address Address extracted by reference
* @param port Port extracted by reference
*/
- static void getAddressAndPortFromSocketLiteral(const std::string &literal, std::string &address, int &port) throw();
+ static void getAddressAndPortFromSocketLiteral(const std::string &literal, std::string &address, int &port) ;
/**
* Translate pipe-separated socket literal list into Address/Port vector.
* @param list Comma-separated Address/Port list. I.e.: '10.95.10.25:4000,10.95.10.25:4001', or 'fed1:4000,fed2:4001'
* @return Address/Port socket items vector
*/
- static socket_v getSocketVectorFromString(const std::string & list) throw();
+ static socket_v getSocketVectorFromString(const std::string & list) ;
/**
* Translate Address/Port vector into comma-separated Address/Port list.
*
* @return Comma-separated Address/Port list. I.e.: '10.95.10.25:4000,10.95.10.25:4001', or 'fed1:4000,fed2:4001'
*/
- static std::string socketVectorAsString(const socket_v & socketVector) throw();
+ static std::string socketVectorAsString(const socket_v & socketVector) ;
/**
@result Returns true when the system is little endian, false if big endian
*/
- static bool littleEndian() throw();
+ static bool littleEndian() ;
/**
Encodes an integer number with 32 bits over a buffer with at least 4 bytes of length.
@param n Number to encode.
\return Buffer with the encoded number.
*/
- static const char* codeInteger(char* result, const int n) throw();
+ static const char* codeInteger(char* result, const int n) ;
/**
Encodes an integer number with 16 bits over a buffer with at least 2 bytes of length.
@param n Number to encode.
\return Buffer with the encoded number.
*/
- static const char* codeShort(char* result, const short int n) throw();
+ static const char* codeShort(char* result, const short int n) ;
/**
Encodes an integer number with 64 bits over a buffer with at least 8 bytes of length.
@param n Number to encode.
\return Buffer with the encoded number.
*/
- static const char* codeInteger64(char* result, const S64 n) throw();
+ static const char* codeInteger64(char* result, const S64 n) ;
/**
Encodes a floating number with 32 bits (according to the standard IEEE-754) over a buffer with at least 4 bytes of length.
@param n Number to encode.
\return Buffer with the encoded number.
*/
- static const char* codeFloat(char* result, const float n) throw();
+ static const char* codeFloat(char* result, const float n) ;
/**
Encodes a floating number with 64 bits (according to the standard IEEE-754) over a buffer with at least 8 bytes of length.
@param n Number to encode.
\return Buffer with the encoded number.
*/
- static const char* codeDouble(char* result, const double n) throw();
+ static const char* codeDouble(char* result, const double n) ;
/**
Decodes an 32 bits integer number contained in a 4-bytes buffer.
@param data Buffer with the encoded number.
@return Value for the number contained in the buffer.
*/
- static int decodeInteger(const char* data) throw();
+ static int decodeInteger(const char* data) ;
/**
Decodes an 16 bits integer number contained in a 2-bytes buffer.
@param data Buffer with the encoded number.
@return Value for the number contained in the buffer.
*/
- static short int decodeShort(const char* data) throw();
+ static short int decodeShort(const char* data) ;
/**
Decodes an 64 bits integer number contained in a 8-bytes buffer.
@param data Buffer with the encoded number.
@return Value for the number contained in the buffer.
*/
- static S64 decodeInteger64(const char* data) throw();
+ static S64 decodeInteger64(const char* data) ;
/**
Decodes an 32 bits floating number (according to the standard IEEE-754) contained in a 4-bytes buffer.
@param data Buffer with the encoded number.
@return Value for the number contained in the buffer.
*/
- static float decodeFloat(const char* data) throw();
+ static float decodeFloat(const char* data) ;
/**
Decodes an 64 bits floating number (according to the standard IEEE-754) contained in a 8-bytes buffer.
@param data Buffer with the encoded number.
@return Value for the number contained in the buffer.
*/
- static double decodeDouble(const char* data) throw();
+ static double decodeDouble(const char* data) ;
/**
* @param isupNumber Isup number decoded by reference.
* @param calledOrCalling True for called party number, false for calling
*/
- static void decodeIsupNumber(const char *buffer, int length, isup_number_t & isupNumber, bool calledOrCalling) throw(RuntimeException);
+ static void decodeIsupNumber(const char *buffer, int length, isup_number_t & isupNumber, bool calledOrCalling) noexcept(false);
/**
* Encodes an ISUP Number (called or calling party number).
* @param buffer Isup number content encoded buffer.
* @param length Isup number content encoded length.
*/
- static void codeIsupNumber(const isup_number_t & isupNumber, bool calledOrCalling, char * buffer, int & length) throw(RuntimeException);
+ static void codeIsupNumber(const isup_number_t & isupNumber, bool calledOrCalling, char * buffer, int & length) noexcept(false);
/**
* Encodes an ISUP Number (called or calling party number).
* @param calledOrCalling True for called party number, false for calling
* @param target Isup number octet string.
*/
- static void codeIsupNumber(const isup_number_t & isupNumber, bool calledOrCalling, std::string & target) throw(RuntimeException);
+ static void codeIsupNumber(const isup_number_t & isupNumber, bool calledOrCalling, std::string & target) noexcept(false);
/**
* Base64 encoding
*
* @return success for read operation
*/
- static bool getContentFromFile(const std::string &pathfile, std::string &content) throw(anna::RuntimeException);
+ static bool getContentFromFile(const std::string &pathfile, std::string &content) noexcept(false);
};
}
projects / anna.git / blobdiff