// :vi sw=4 ts=4 noet:
/*
==================================================================================
	Copyright (c) 2019 Nokia
	Copyright (c) 2018-2019 AT&T Intellectual Property.

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

	   http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
==================================================================================
*/
/*
	Mnemonic:	ring_static.c
	Abstract:	Implements a ring of information (probably to act as a
				message queue).
	Author:		E. Scott Daniels
	Date:		31 August 2017
*/

#ifndef _ring_static_c
#define _ring_static_c

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <errno.h>
#include <string.h>
#include <stdint.h>
#include <sys/eventfd.h>

#define RING_FAST 1			// when set we skip nil pointer checks on the ring pointer

/*
	This returns the ring's pollable file descriptor. If one does not exist, then
	it is created.
*/
static int uta_ring_getpfd( void* vr ) {
	ring_t*		r;

	if( !RING_FAST ) {								// compiler should drop the conditional when always false
		if( (r = (ring_t*) vr) == NULL ) {
			return 0;
		}
	} else {
		r = (ring_t*) vr;
	}

	if( r->pfd < 0 ) {
		r->pfd = eventfd( 0, EFD_SEMAPHORE | EFD_NONBLOCK );
	}

	return r->pfd;
}

/*
	Make a new ring.
*/
static void* uta_mk_ring( int size ) {
	ring_t*	r;
	uint16_t max;

	if( size <= 0 || (r = (ring_t *) malloc( sizeof( *r ) )) == NULL ) {
		return NULL;
	}

	r->head = r->tail = 0;

	max = (r->head - 1);
	if( size >= max ) {
		size--;
	}

	r->nelements = size;		// because we always have an empty element when full
	if( (r->data = (void **) malloc( sizeof( void** ) * (r->nelements + 1) )) == NULL ) {
		free( r );
		return NULL;
	}

	memset( r->data, 0, sizeof( void** ) * r->nelements );
	r->pfd = eventfd( 0, EFD_SEMAPHORE | EFD_NONBLOCK );		// in semaphore mode counter is maintained with each insert/extract
	return (void *) r;
}

/*
	Ditch the ring. The caller is responsible for extracting any remaining
	pointers and freeing them as needed.
*/
static void uta_ring_free( void* vr ) {
	ring_t* r;

	if( (r = (ring_t*) vr) == NULL ) {
		return;
	}

	free( r );
}


/*
	Pull the next data pointer from the ring; null if there isn't
	anything to be pulled.
*/
static inline void* uta_ring_extract( void* vr ) {
	ring_t*		r;
	uint16_t	ti;		// real index in data
	int64_t	ctr;		// pfd counter

	if( !RING_FAST ) {								// compiler should drop the conditional when always false
		if( (r = (ring_t*) vr) == NULL ) {
			return 0;
		}
	} else {
		r = (ring_t*) vr;
	}

	if( r->tail == r->head ) {			// empty ring
		return NULL;
	}

	ti = r->tail;
	r->tail++;
	if( r->tail >= r->nelements ) {
		r->tail = 0;
	}

	read( r->pfd, &ctr, sizeof( ctr )  );				// when not in semaphore, this zeros the counter and value is meaningless
/*
future -- investigate if it's possible only to set/clear when empty or going to empty
	if( r->tail == r->head ) {								// if this emptied the ring, turn off ready
	}
*/
	return r->data[ti];
}

/*
	Insert the pointer at the next open space in the ring.
	Returns 1 if the inert was ok, and 0 if the ring is full.
*/
static inline int uta_ring_insert( void* vr, void* new_data ) {
	ring_t*		r;
	int64_t	inc = 1;				// used to set the counter in the pfd

	if( !RING_FAST ) {								// compiler should drop the conditional when always false
		if( (r = (ring_t*) vr) == NULL ) {
			return 0;
		}
	} else {
		r = (ring_t*) vr;
	}

	if( r->head+1 == r->tail || (r->head+1 >= r->nelements && !r->tail) ) {		// ring is full
		return 0;
	}

	write( r->pfd, &inc, sizeof( inc ) );
/*
future -- investigate if it's possible only to set/clear when empty or going to empty
	if( r->tail == r->head ) {								// turn on ready if ring was empty
	}
*/

	r->data[r->head] = new_data;
	r->head++;
	if( r->head >= r->nelements ) {
		r->head = 0;
	}

	return 1;
}



#endif