#include <anna/core/util/Tokenizer.hpp>
#include <algorithm>
+#include <fstream>
+#include <sstream>
using namespace anna;
#define PAGE_WIDTH_LENGTH 80
-string functions::getVersion() throw() {
+static const std::string base64_chars =
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+ "abcdefghijklmnopqrstuvwxyz"
+ "0123456789+/";
+
+
+string functions::getVersion() {
static const int version = ANNA_VERSION;
string result;
int mainVersion = (version & 0xff00) >> 8;
/*
(1) Solo coge los dos primeros digitos del numero de release
*/
-string functions::getArchitecture() throw() {
+string functions::getArchitecture() {
string result;
WHEN_MULTITHREAD(result = "/MT");
WHEN_SINGLETHREAD(result = "/ST");
}
string functions::asString(const int number)
-throw() {
+{
char aux [16];
sprintf(aux, "%d", number);
return string(aux);
}
string functions::asString(const S64 number)
-throw() {
+{
char aux [24];
//sprintf(aux, "%lld", number);
#ifdef __anna64__
}
string functions::asString(const unsigned int number)
-throw() {
+{
char aux [16];
sprintf(aux, "%u", number);
return string(aux);
}
string functions::asString(const U64 number)
-throw() {
+{
char aux [16];
//sprintf(aux, "%llu", number);
#ifdef __anna64__
}
string functions::asString(const float number, const char* format)
-throw() {
+{
char aux [64];
sprintf(aux, format, number);
return string(aux);
}
string functions::asString(const double number, const char* format)
-throw() {
+{
char aux [64];
sprintf(aux, format, number);
return string(aux);
}
string functions::asDateTime(const Second &second)
-throw() {
+{
char aux [DateTimeSizeString];
return std::string(asDateTime(second, aux));
}
const char* functions::asDateTime(const Second &second, char* result)
-throw() {
+{
struct tm* tt = localtime((time_t*) & second);
sprintf(
- result, "%02d/%02d/%4d %02d:%02d:%02d",
+ result, "%02u/%02u/%4u %02u:%02u:%02u",
tt->tm_mday, tt->tm_mon + 1, tt->tm_year + 1900,
tt->tm_hour, tt->tm_min, tt->tm_sec
);
}
std::string functions::asString(const DataBlock& dataBlock, const int characterByLine)
-throw() {
+{
return dataBlock.asString(characterByLine);
}
string functions::asHexString(const int number)
-throw() {
+{
char aux [16];
sprintf(aux, "0x%x", number);
return string(aux);
}
string functions::asHexString(const S64 number)
-throw() {
+{
char aux [32];
//sprintf(aux, "0x%llx", number);
#ifdef __anna64__
// from a version by Allen Holub (see Andrew Binstock, "Hashing Revisited"
// Dr. Dobb's Journal, April 1996)
S64 functions::hash(const char* p)
-throw() {
+{
static const int long_bits = sizeof(S64) << 3;
static const int one_eighth = long_bits >> 3;
static const int three_fourths = long_bits * 3 / 4;
//static
std::string functions::asHexString(const DataBlock& dataBlock)
-throw() {
+{
const char* buffer = dataBlock.getData();
const int size = dataBlock.getSize();
string result;
*/
//static
DataBlock& functions::fromHexString(const std::string& hexString, DataBlock& target)
-throw(RuntimeException) {
+noexcept(false) {
if((hexString.length() % 2) != 0)
throw RuntimeException("functions::fromHexString | Invalid string length", ANNA_FILE_LOCATION);
}
string functions::asString(const char* format, ...)
-throw() {
+{
va_list ap;
char aux [1024];
va_start(ap, format);
}
void functions::sleep(const Millisecond &millisecond)
-throw() {
+{
timespec req;
timespec rem;
req.tv_sec = millisecond.getValue() / 1000; // segundos
}
bool functions::asBool(const char* str)
-throw(RuntimeException) {
+noexcept(false) {
if(str == NULL)
return false;
}
S64 functions::asInteger64(const char* str)
-throw() {
+{
S64 number = 0;
//sscanf(str, "%lld", &number);
#ifdef __anna64__
}
pthread_t functions::getCurrentThread()
-throw() {
+{
WHEN_MULTITHREAD(return pthread_self());
WHEN_SINGLETHREAD(return 0);
}
bool functions::isLike(const char* pattern, const std::string& _value)
-throw(RuntimeException) {
+noexcept(false) {
const char* value = _value.c_str();
regex_t preg;
int ret;
/*static*/
S64 functions::merge(const char* whatis, const int n1, const int n2, const int bitShift)
-throw(RuntimeException) {
+noexcept(false) {
if(bitShift > intBitSize) {
string msg(functions::asString("%s | N1: 0x%x | N2: 0x%x | bitShift: %d | bitShift must be less than %d", whatis, n1, n2, bitShift, intBitSize));
throw RuntimeException(msg, ANNA_FILE_LOCATION);
* Basado en el algoritmo de http://www-graphics.stanford.edu/~seander/bithacks.html#IntegerLogLookup
*/
int functions::log2(const unsigned int v)
-throw() {
+{
static const signed char LogTable256[] = {
-1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
return r;
}
-std::string functions::entriesAsString(int number, const char * wordForSingular, const char * wordForPlural) throw() {
+std::string functions::entriesAsString(int number, const char * wordForSingular, const char * wordForPlural) {
std::string result;
std::string singular = (wordForSingular ? wordForSingular : "entry");
std::string plural = (wordForPlural ? wordForPlural : "entries");
}
-std::string functions::justify(const std::string & title, TextJustifyMode::_v mode, char filler) throw() {
+std::string functions::justify(const std::string & title, TextJustifyMode::_v mode, char filler) {
std::string result;
int d_size = title.size();
int repeat = PAGE_WIDTH_LENGTH - d_size - 1;
}
-std::string functions::highlight(const std::string & title, TextHighlightMode::_v mode, char filler, bool appendCR) throw() {
+std::string functions::highlight(const std::string & title, TextHighlightMode::_v mode, char filler, bool appendCR) {
std::string result;
int ou_repeat = title.size();
int lr_repeat = PAGE_WIDTH_LENGTH - ou_repeat - 1;
}
-std::string functions::tab(const std::string & text, int tabSpaces) throw() {
+std::string functions::tab(const std::string & text, int tabSpaces) {
std::string result;
size_t pos, from = 0;
std::string tab, crTab = "\n";
}
-bool functions::endsWith(const std::string & pattern, const std::string & suffix, std::string & preffix) throw() {
+bool functions::endsWith(const std::string & pattern, const std::string & suffix, std::string & preffix) {
preffix = "";
if(pattern.size() < suffix.size()) return false;
}
-bool functions::startsWith(const std::string & pattern, const std::string & preffix, std::string & suffix) throw() {
+bool functions::startsWith(const std::string & pattern, const std::string & preffix, std::string & suffix) {
suffix = "";
if(pattern.size() < preffix.size()) return false;
}
-std::string functions::replace(const std::string & text, const char *item, const char *target, bool all) throw() {
+std::string functions::replace(const std::string & text, const char *item, const char *target, bool all) {
std::string result = text;
if(!item || !target) return result; // protection for NULL strings provided
}
-std::string functions::addQuotationMarks(const std::string & str) throw() {
+std::string functions::addQuotationMarks(const std::string & str) {
std::string result = "'";
result += str;
result += "'";
}
-std::string functions::addQuotationMarks(const char * str) throw() {
+std::string functions::addQuotationMarks(const char * str) {
std::string result = "'";
result += (str ? str : "<null>");
result += "'";
}
-std::string functions::addQuotationMarks(const int & integer) throw() {
+std::string functions::addQuotationMarks(const int & integer) {
std::string result = "'";
result += anna::functions::asString(integer);
result += "'";
}
-std::string functions::vectorToStringRepresentation(const std::vector<int> & v, const char separator) throw() {
+std::string functions::vectorToStringRepresentation(const std::vector<int> & v, const char separator) {
std::string result = "";
if(v.size() != 0) {
}
-std::string functions::vectorToStringRepresentation(const std::vector<std::string> & v, const char separator) throw() {
+std::string functions::vectorToStringRepresentation(const std::vector<std::string> & v, const char separator) {
std::string result = "";
if(v.size() != 0) {
}
-std::string functions::socketLiteralAsString(const std::string & address, int port) throw() {
+std::string functions::socketLiteralAsString(const std::string & address, int port) {
std::string result = address;
result += ":";
result += anna::functions::asString(port);
}
-std::string functions::asAsciiString(const char * buffer, int size, bool & isFullyPrintable) throw() {
+std::string functions::asAsciiString(const char * buffer, int size, bool & isFullyPrintable) {
std::string result;
// Supposed printable by default:
isFullyPrintable = true;
}
-std::string functions::getHostname() throw() {
+std::string functions::getHostname() {
char aux[255];
std::string result = "<hostname>";
return result;
}
-std::string functions::getDomainname() throw() {
+std::string functions::getDomainname() {
char aux[256];
std::string result = "<domainname>";
return result;
}
-std::string functions::getFQDN(const char *hostname, const char *domainname) throw() {
+std::string functions::getFQDN(const char *hostname, const char *domainname) {
std::string hn = hostname ? hostname : (functions::getHostname());
std::string dn = domainname ? domainname : (functions::getDomainname());
// FQDN is limited to 255 bytes, with aditional restriction: 63 bytes label within a domain name.
return fqdn;
}
-std::string functions::getHostnameIP() throw() {
+std::string functions::getHostnameIP() {
std::string result = "";
struct hostent *he;
struct in_addr **addr_list;
}
-anna::DataBlock functions::rawIpPresentationAsRaw(const std::string & rawPresentation) throw(anna::RuntimeException) {
+anna::DataBlock functions::rawIpPresentationAsRaw(const std::string & rawPresentation) noexcept(false) {
int length = rawPresentation.size();
if(length != 8 && length != 32)
}
-std::string functions::rawIpAsRawIpPresentation(const anna::DataBlock & db) throw(anna::RuntimeException) {
+std::string functions::rawIpAsRawIpPresentation(const anna::DataBlock & db) noexcept(false) {
int length = db.getSize();
if(length != 4 && length != 16)
//
// http://tools.ietf.org/html/rfc5952: canonical text representation recommendation
-bool functions::isIPv4(const std::string & ip, IPv4Type::_v ipv4Type) throw() {
+bool functions::isIPv4(const std::string & ip, IPv4Type::_v ipv4Type) {
if(ipv4Type == IPv4Type::Estrict) {
// La expresión regular no controla si hay mas de 3 puntos:
int n_dot = 0;
}
-bool functions::isIPv6(const std::string & ip) throw() {
+bool functions::isIPv6(const std::string & ip) {
// Chequeo de digitos permitidos:
for(int k = 0; k < ip.length(); k++) {
bool digit = isdigit(ip[k]);
}
-std::string functions::IPv4To6(const std::string & ip) throw(anna::RuntimeException) {
+std::string functions::IPv4To6(const std::string & ip) noexcept(false) {
if(!isIPv4(ip, IPv4Type::Estrict) && !isIPv4(ip, IPv4Type::Compatible) && !isIPv4(ip, IPv4Type::Mapped))
throw anna::RuntimeException("functions::IPv4To6 | Expected IPv4, IPv4-compatible or IPv4-mapped address format", ANNA_FILE_LOCATION);
}
-std::string functions::normalizeIP(const std::string & ip) throw(anna::RuntimeException) {
+std::string functions::normalizeIP(const std::string & ip) noexcept(false) {
std::string result = ip;
// std::transform(result.begin(), result.end(), result.begin(), (int (*)(int))std::tolower);
std::transform(result.begin(), result.end(), result.begin(), ::tolower);
}
-bool functions::sameIP(const std::string & ip1, const std::string & ip2) throw(anna::RuntimeException) {
+bool functions::sameIP(const std::string & ip1, const std::string & ip2) noexcept(false) {
//if (ip1 == ip2) return true; it should validate wrong-format addresses
return (normalizeIP(ip1) == normalizeIP(ip2));
}
-bool functions::matchIPv6(const std::string & _ipv6, const std::string & preffixedIpv6) throw(anna::RuntimeException) {
+bool functions::matchIPv6(const std::string & _ipv6, const std::string & preffixedIpv6) noexcept(false) {
size_t preffixPos = preffixedIpv6.find("/");
if(preffixPos == std::string::npos)
}
-anna::DataBlock functions::ipAsRaw(const std::string & ip) throw(anna::RuntimeException) {
+anna::DataBlock functions::ipAsRaw(const std::string & ip) noexcept(false) {
anna::DataBlock result(true);
if(isIPv4(ip)) {
}
-std::string functions::rawIpAsString(const char *buffer, int bufferLength, bool normalize) throw(anna::RuntimeException) {
+std::string functions::rawIpAsString(const char *buffer, int bufferLength, bool normalize) noexcept(false) {
std::string result = "";
char str[INET6_ADDRSTRLEN];
}
-void functions::getAddressAndPortFromSocketLiteral(const std::string &literal, std::string &address, int &port) throw() {
+void functions::getAddressAndPortFromSocketLiteral(const std::string &literal, std::string &address, int &port) {
size_t pos = literal.find_last_of(":");
size_t lastPos = literal.size() - 1;
address = ""; port = -1; // assume error
}
-socket_v functions::getSocketVectorFromString(const std::string & list) throw() {
+socket_v functions::getSocketVectorFromString(const std::string & list) {
socket_v result;
std::string address;
int port;
return result;
}
-std::string functions::socketVectorAsString(const socket_v & socketVector) throw() {
+std::string functions::socketVectorAsString(const socket_v & socketVector) {
std::string result;
socket_v_it it;
socket_v_it it_min(socketVector.begin());
}
bool functions::littleEndian()
-throw() {
+{
int i = 1;
char *p = (char *) &i;
if (p[0] == 1) return true;
}
const char* functions::codeInteger(char* result, const int n)
-throw() {
+{
int aux(htonl(n));
char* w((char*) &aux);
*result = *w;
}
const char* functions::codeShort(char* result, const short int n)
-throw() {
+{
short int aux(htons(n));
char* w((char*) &aux);
*result = *w;
}
const char* functions::codeInteger64(char* result, const S64 n)
-throw() {
+{
S64 aux(0xffffffff);
int n2;
aux <<= 32;
/*static*/
const char* functions::codeFloat(char* result, const float n)
-throw() {
+{
int ii;
anna_memcpy(&ii, &n, sizeof(n));
return functions::codeInteger(result, ii);
/*static*/
const char* functions::codeDouble(char* result, const double n)
-throw() {
+{
S64 ii;
anna_memcpy(&ii, &n, sizeof(n));
return functions::codeInteger64(result, ii);
}
int functions::decodeInteger(const char* data)
-throw() {
+{
int result;
char* w((char*) &result);
*w = *data;
}
short int functions::decodeShort(const char* data)
-throw() {
+{
short int result;
char* w((char*) &result);
*w = *data;
}
S64 functions::decodeInteger64(const char* data)
-throw() {
+{
S64 result(decodeInteger(data));
result <<= 32;
return result |= (decodeInteger(data + sizeof(int)) & 0xffffffff);
/*static*/
float functions::decodeFloat(const char* data)
-throw() {
+{
float result;
int ii = functions::decodeInteger(data);
anna_memcpy(&result, &ii, sizeof(result));
/*static*/
double functions::decodeDouble(const char* data)
-throw() {
+{
double result;
S64 ii = functions::decodeInteger64(data);
anna_memcpy(&result, &ii, sizeof(result));
-void functions::decodeIsupNumber(const char *buffer, int length, isup_number_t & isupNumber, bool calledOrCalling) throw(anna::RuntimeException) {
+void functions::decodeIsupNumber(const char *buffer, int length, isup_number_t & isupNumber, bool calledOrCalling) noexcept(false) {
#define DECODE2BYTES_INDX_VALUETYPE(buffer,indx,value_type) ((((value_type)buffer[indx] << 8) & 0xFF00) + ((value_type)buffer[indx+1] & 0x00FF))
isupNumber.reset();
isupNumber.OddEven = (short)((buffer[0] >> 7) & 0x01);
}
-void functions::codeIsupNumber(const isup_number_t & isupNumber, bool calledOrCalling, std::string & target) throw(anna::RuntimeException) {
+void functions::codeIsupNumber(const isup_number_t & isupNumber, bool calledOrCalling, std::string & target) noexcept(false) {
// Checkings:
if(isupNumber.OddEven < 0 || isupNumber.OddEven > 1)
throw anna::RuntimeException("functions::codeIsupNumber | Isup number 'OddEven' field out of range [0,1]", ANNA_FILE_LOCATION);
}
-void functions::codeIsupNumber(const isup_number_t & isupNumber, bool calledOrCalling, char * buffer, int & length) throw(anna::RuntimeException) {
+void functions::codeIsupNumber(const isup_number_t & isupNumber, bool calledOrCalling, char * buffer, int & length) noexcept(false) {
std::string target;
codeIsupNumber(isupNumber, calledOrCalling, target);
length = target.size();
memcpy(buffer, target.c_str(), length);
}
+
+static inline bool is_base64(U8 c) {
+ return (isalnum(c) || (c == '+') || (c == '/'));
+}
+
+std::string functions::encodeBase64(const U8* buf, unsigned int bufLen) {
+ std::string ret;
+ int i = 0;
+ int j = 0;
+ U8 char_array_3[3];
+ U8 char_array_4[4];
+
+ while (bufLen--) {
+ char_array_3[i++] = *(buf++);
+ if (i == 3) {
+ char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
+ char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
+ char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
+ char_array_4[3] = char_array_3[2] & 0x3f;
+
+ for(i = 0; (i <4) ; i++)
+ ret += base64_chars[char_array_4[i]];
+ i = 0;
+ }
+ }
+
+ if (i)
+ {
+ for(j = i; j < 3; j++)
+ char_array_3[j] = '\0';
+
+ char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
+ char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
+ char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
+ char_array_4[3] = char_array_3[2] & 0x3f;
+
+ for (j = 0; (j < i + 1); j++)
+ ret += base64_chars[char_array_4[j]];
+
+ while((i++ < 3))
+ ret += '=';
+ }
+
+ return ret;
+}
+
+std::string functions::decodeBase64(const std::string & encodedString) {
+ int in_len = encodedString.size();
+ int i = 0;
+ int j = 0;
+ int in_ = 0;
+ U8 char_array_4[4], char_array_3[3];
+ std::string ret;
+
+ while (in_len-- && ( encodedString[in_] != '=') && is_base64(encodedString[in_])) {
+ char_array_4[i++] = encodedString[in_]; in_++;
+ if (i ==4) {
+ for (i = 0; i <4; i++)
+ char_array_4[i] = base64_chars.find(char_array_4[i]);
+
+ char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
+ char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
+ char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+
+ for (i = 0; (i < 3); i++)
+ ret += char_array_3[i];
+ i = 0;
+ }
+ }
+
+ if (i) {
+ for (j = i; j <4; j++)
+ char_array_4[j] = 0;
+
+ for (j = 0; j <4; j++)
+ char_array_4[j] = base64_chars.find(char_array_4[j]);
+
+ char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
+ char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
+ char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+
+ for (j = 0; (j < i - 1); j++) ret += char_array_3[j];
+ }
+
+ return ret;
+}
+
+bool functions::getContentFromFile(const std::string &pathfile, std::string &content) noexcept(false) {
+
+ std::ifstream inFile(pathfile.c_str(), std::ifstream::in);
+ if(!inFile.good()) {
+ throw RuntimeException(anna::functions::asString("Unable to open file '%s'", pathfile.c_str()), ANNA_FILE_LOCATION);
+ }
+
+ std::stringstream strStream;
+ strStream << inFile.rdbuf(); //read the file
+ content = strStream.str(); // holds the content of the file
+ inFile.close();
+
+ return true;
+}
+
projects / anna.git / blobdiff