blob: a1cd87d4a369bb1140ef4783139589e629b1702d [file] [log] [blame]
/* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
/*
* Copyright (c) 2011 University of California, Los Angeles
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation;
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Author: Ilya Moiseenko <iliamo@cs.ucla.edu>
*/
#include "ccn_indexbuf.h"
/**
* @file ccn_indexbuf.c
* @brief Support for expandable buffer of non-negative values.
*
* Part of the CCNx C Library.
*
* Copyright (C) 2008, 2009 Palo Alto Research Center, Inc.
*
* This library is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License version 2.1
* as published by the Free Software Foundation.
* This library 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
* Lesser General Public License for more details. You should have received
* a copy of the GNU Lesser General Public License along with this library;
* if not, write to the Free Software Foundation, Inc., 51 Franklin Street,
* Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#define ELEMENT size_t
/**
* Create a new indexbuf.
*/
struct ccn_indexbuf *
ccn_indexbuf_create(void)
{
struct ccn_indexbuf *c;
c = (ccn_indexbuf*)calloc(1, sizeof(*c));
return(c);
}
/**
* Deallocate indexbuf.
*/
void
ccn_indexbuf_destroy(struct ccn_indexbuf **cbp)
{
struct ccn_indexbuf *c = *cbp;
if (c != NULL) {
if (c->buf != NULL) {
free(c->buf);
}
free(c);
*cbp = NULL;
}
}
/**
* Expand buffer as necessary to hold at least n more values.
* @returns pointer to reserved space
*/
ELEMENT *
ccn_indexbuf_reserve(struct ccn_indexbuf *c, size_t n)
{
size_t newlim = n + c->n;
size_t oldlim = c->limit;
ELEMENT *buf = c->buf;
if (newlim < n)
return(NULL);
if (newlim > oldlim) {
if (2 * oldlim > newlim)
newlim = 2 * oldlim;
buf = (size_t*)realloc(c->buf, newlim * sizeof(ELEMENT));
if (buf == NULL)
return(NULL);
memset(buf + oldlim, 0, (newlim - oldlim) * sizeof(ELEMENT));
c->buf = buf;
c->limit = newlim;
}
buf += c->n;
return(buf);
}
/**
* Append multiple elements to the indexbuf.
* @returns 0 for success, -1 for failure.
*/
int
ccn_indexbuf_append(struct ccn_indexbuf *c, const ELEMENT *p, size_t n)
{
ELEMENT *dst = ccn_indexbuf_reserve(c, n);
if (dst == NULL)
return(-1);
memcpy(dst, p, n * sizeof(ELEMENT));
c->n += n;
return(0);
}
/**
* Append v to the indexbuf
* @returns 0 for success, -1 for failure.
*/
int
ccn_indexbuf_append_element(struct ccn_indexbuf *c, ELEMENT v)
{
ELEMENT *dst = ccn_indexbuf_reserve(c, 1);
if (dst == NULL)
return(-1);
*dst = v;
c->n += 1;
return(0);
}
/**
* @returns index at which the element was found or appended, or -1 if not found.
*/
int
ccn_indexbuf_member(struct ccn_indexbuf *x, ELEMENT val)
{
int i;
if (x == NULL)
return (-1);
for (i = x->n - 1; i >= 0; i--)
if (x->buf[i] == val)
return(i);
return(-1);
}
/**
* Removes up to one instance of val from the indexbuf.
* Order of elements not preserved.
*/
void
ccn_indexbuf_remove_element(struct ccn_indexbuf *x, ELEMENT val)
{
int i;
if (x == NULL) return;
for (i = x->n - 1; i >= 0; i--)
if (x->buf[i] == val) {
x->buf[i] = x->buf[--x->n]; /* move last element into vacant spot */
return;
}
}
/**
* @returns index at which the element was found or appended,
* or -1 in case of error.
*/
int
ccn_indexbuf_set_insert(struct ccn_indexbuf *x, ELEMENT val)
{
int i;
if (x == NULL)
return (-1);
for (i = 0; i < (int)x->n; i++)
if (x->buf[i] == val)
return(i);
if (ccn_indexbuf_append_element(x, val) < 0)
return(-1);
return(i);
}
/**
* Removes first occurrence of val, preserving order
* @returns index at which the element was found,
* or -1 if the element was not found.
*/
int
ccn_indexbuf_remove_first_match(struct ccn_indexbuf *x, ELEMENT val)
{
int i;
int n;
if (x == NULL)
return (-1);
for (i = 0, n = x->n; i < n; i++) {
if (x->buf[i] == val) {
if (i + 1 < n)
memmove(&(x->buf[i]),
&(x->buf[i + 1]),
sizeof(x->buf[i]) * (n - i - 1));
x->n--;
return(i);
}
}
return(-1);
}
/**
* If val is present in the indexbuf, move it to the final place.
*/
void
ccn_indexbuf_move_to_end(struct ccn_indexbuf *x, ELEMENT val)
{
int i;
int n;
if (x == NULL)
return;
for (i = 0, n = x->n; i + 1 < n; i++) {
if (x->buf[i] == val) {
memmove(&(x->buf[i]),
&(x->buf[i + 1]),
sizeof(x->buf[i]) * (n - i - 1));
x->buf[n - 1] = val;
return;
}
}
}
/**
* If val is present in the indexbuf, move it to the first place.
*/
void
ccn_indexbuf_move_to_front(struct ccn_indexbuf *x, ELEMENT val)
{
int i;
int n;
if (x == NULL)
return;
for (i = 0, n = x->n; i < n; i++) {
if (x->buf[i] == val) {
memmove(&(x->buf[1]),
&(x->buf[0]),
sizeof(x->buf[i]) * i);
x->buf[0] = val;
return;
}
}
}