api.cpp

Go to the documentation of this file.

#include <api.h>

void empty_buffer(FILE* stream)
{
    int c = 0;

    while (c != '\n' && c != EOF)
        c = fgetc(stream);
}

bool read_stdin(char *msg, int length, FILE *stream)
{

    char *returnPosition = NULL;

    if(fgets(msg, length, stream) != NULL)
    {

        returnPosition = strchr(msg, '\n');

        if(returnPosition != NULL)
            *returnPosition = '\0';
        else
            empty_buffer(stream);
        return true;
    }
    else
    {
        empty_buffer(stream);
        return false;
    }

}

void format(unsigned char * msg, unsigned long v, int l)
{

  int i;

  for(i = l ; i ; i--){
    msg[l - i] = v >> (8 * (i - 1));
    v -= (v >> (8 * (i - 1))) << (8 * (i - 1));
  }

}

unsigned long long int split(const unsigned char *msg, int begin, int end)
{
    unsigned long long int ret;
    int i, offset_b = 8 - (begin % 8), offset_e = end % 8, and_b = (1 << offset_b) - 1,
            and_e = ((1 << offset_e) - 1) << (8 - offset_e), l = (end - begin + 7) / 8,
            start = begin / 8;

    ret = msg[start] & and_b;

    for(i = 1 ; i < l ; i++)
    {
        ret <<= 8;
        ret += msg[i + start] & and_b;
    }

    ret <<= offset_e;
    ret += msg[i + start] & and_e;

    return ret;
}

void split(const unsigned char *msg, int begin, int end, char *out)
{
    int i;

    for(i = begin ; i < end ; i++)
        out[i - begin] = msg[i];
}

void read_opts(const unsigned char *msg, int nOptions, bool *opts)
{
    int i;

    for(i = 0 ; i < nOptions ; i++)
        opts[i] = msg[(i / 8) + 1] & (1 << (7 - (i % 8)));
}

void clear_string(char *s, int n)
{
    memset(s, '\0', n);
}

void print_hexa(const unsigned char *msg, int l, FILE *stream)
{

  int i;

  for(i = 0 ; i < l ; i++){
    if(msg[i] < 0x10)
      fprintf(stream, "0%X", msg[i]);
    else
      fprintf(stream, "%X", msg[i]);
    if(!((i + 1) % OCTET))
      fprintf(stream, " ");
    if(!((i + 1) % NEW_LINE))
      fprintf(stream, "\n");
  }
  printf("\n");
}

QByteArray hexa2bin(QByteArray src)
{
    QByteArray ret, hexByte;
    QDataStream ds(&ret, QIODevice::WriteOnly);
    quint8 hex;
    int i, j;

    for(i = 0 ; i < src.size() ; i += 2)
    {
        hex = 0;
        hexByte.clear();
        for(j = 0 ; j < 2 ; j++)
            hexByte.append(src[i + j]);
        hex = hexByte.toInt(NULL, 16);
        ds << hex;
    }

    return ret;
}

QByteArray split(QByteArray src, int begin, int end)
{
    QByteArray ret;
    int i, n = end - begin;

    for(i = 0 ; i < n ; i++)
        ret += src[i + begin];

    return ret;
}
/*
struct gpsPosition_t getPosition()
{
    struct gpsPosition_t p;
    QFile file(POSITION_FILE);
    QByteArray line;
    QList<QByteArray> splitLine;

    if(file.open(QIODevice::ReadOnly))
    {
        while(!file.atEnd())
        {
            line = file.readLine();
            splitLine = line.split(':');
            if(splitLine[0] == QByteArray(GPS_CONF_LATITUDE))
                p._latitude = splitLine[1].toInt();
            else if(splitLine[0] == QByteArray(GPS_CONF_LONGITUDE))
                p._longitude = splitLine[1].toInt();
            else if(splitLine[0] == QByteArray(GPS_CONF_ALTITUDE))
                p._altitude = splitLine[1].toInt();
            else if(splitLine[0] == QByteArray(GPS_CONF_SEMI_MAJOR_CONFIDENCE))
                p._semiMajorConfidence = splitLine[1].toUInt();
            else if(splitLine[0] == QByteArray(GPS_CONF_SEMI_MINOR_CONFIDENCE))
                p._semiMinorConfidence = splitLine[1].toUInt();
            else if(splitLine[0] == QByteArray(GPS_CONF_SEMI_MAJOR_ORIENTATION))
                p._semiMajorOrientation = splitLine[1].toUInt();
            else if(splitLine[0] == QByteArray(GPS_CONF_TIMESTAMP))
                p._timestamp = splitLine[1].toULongLong();
            else if(splitLine[0] == QByteArray(GPS_CONF_SPEED))
                p._speed = splitLine[1].toUInt();
        }
    }
    else
        memset(&p, DEFAULT_VALUE_POSITION, sizeof p);

    return p;
}
*/
QString printBitString(BIT_STRING_t b)
{
    QString s = "{";
    int i;
    for(i=0; i<((8*b.size) - b.bits_unused) - 1; i++)
        (b.buf[i/8] & (1 << (((((i/8)+1)*8)-1)-i)))? s += "true, ":s += "false, ";
    (b.buf[i/8] & (1 << (((((i/8)+1)*8)-1)-i)))? s += "true":s += "false";
    s += "}";
    return s;
}

int validate_unsigned_int(cfg_t *cfg, cfg_opt_t *opt)
{
    long value = cfg_opt_getnint(opt, cfg_opt_size(opt) - 1);
    if(value < 0)
    {
        cfg_error(cfg, "integer option '%s' must be positive in section '%s'",
        opt->name, cfg->name);
        return -1;
    }
    return 0;
}

BIT_STRING_t makeBitString(int nbits, cfg_t* cfg, const char* opt_name)
{
    BIT_STRING_t bs;
    bs.size = (nbits + 7) / 8;
    bs.bits_unused = (8 - (nbits % 8)) % 8;
    bs.buf = (u_int8_t*) calloc(bs.size, 1);
    for(int i=0; i<nbits; i++)
    {
        bs.buf[i/8] |= cfg_getnbool(cfg, opt_name, i) << (7 - (i % 8));
    }
    return bs;
}

quint64 circAtLat(long l)
{
    int L = l / 10000000;

    quint64 ret = 2 * M_PI * (cos(L / (180 / M_PI)) * EARTH_RADIUS);

    return ret;
}

unsigned int diameter(long begin, long end, quint64 circ)
{
    unsigned int tmp = abs(end - begin);
    //tmp *= tmp < 0 ? -1 : 1;
    tmp *= circ / 360;
    return tmp;
}

double dist(qint32 x1, qint32 y1, qint32 x2, qint32 y2)
{
    //double a = pow((x2 - x1), 2);
    //double b = pow((y2 - y1), 2);
    //double res = sqrt(a+b);
    return sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
}

double f(long x, long y, double lengthA, double lengthB, e_shape shape)
{
    long longueur;
    long largeur;

    switch((int)shape)
    {
    case shape_circle:
        if(lengthA != 0)
            return 1-pow((x/lengthA),2)-pow((y/lengthA),2);
        else
            return -1;
        break;
    case shape_rectangle:
        if(lengthA != 0 && lengthB != 0)
        {
            longueur = 1-pow((x/lengthA),2);
            largeur = 1-pow((y/lengthB),2);
            return longueur<largeur?longueur:largeur;
        }
        else
            return -1;
        break;
    case shape_ellipse:
        if(lengthA != 0 && lengthB != 0)
            return 1-((x/lengthA)*(x/lengthA))-((y/lengthB)*(y/lengthB));
        else
            return -1;
        break;
    case shape_none:
    default:
        return -1;
        break;
    }
}

int g(double dist_r, double dist_f, double dist_fr, int angleThreshold)
{
    double FSR = acos((pow(dist_r, 2) + pow(dist_f, 2) - pow(dist_fr, 2)) / (2*dist_r*dist_f));
    if((dist_r < dist_r) && (dist_f < itsGnDefaultMaxCommunicationRange) && (FSR < angleThreshold))
        return 1;
    else
        return -1;
}