linear_sequence.c

#include <stdlib.h>
#include <stdio.h>
#include "linear_sequence.h"

#define ITER(it) ((ItHandle)it)
#define SEQ(seq) ((SeqHandle)seq)
#define Deref LSQ_DereferenceIterator

typedef struct{
    LSQ_BaseTypeT *items;
    unsigned long int size;
} Sequense, *SeqHandle;

typedef enum{
    ITERATOR_NORMAL,
    ITERATOR_BEFORE_FIRST,
    ITERATOR_PAST_REAR,
    ITERATOR_UNKNOWN_SHIT
} IteratorState;

typedef struct{
    SeqHandle handle;
    LSQ_IntegerIndexT pos;
    IteratorState state;
} Iterator, *ItHandle;

void Resize(SeqHandle h, int by){
    h->size += by;
    h->items = realloc(h->items, h->size * sizeof(LSQ_BaseTypeT));
}

inline void ShiftMemory(LSQ_BaseTypeT *Dest, int size, LSQ_IntegerIndexT shift){
    memmove(Dest + shift, Dest, sizeof(LSQ_BaseTypeT) * size);
}

inline int IsIteratorOutOfBounds(ItHandle iter){
    IteratorState state = iter->state;
    return state == ITERATOR_BEFORE_FIRST || state == ITERATOR_PAST_REAR;
}

inline ItHandle CreateIterator(LSQ_HandleT h, LSQ_IntegerIndexT pos, IteratorState s){
    ItHandle it = malloc(sizeof(Iterator));
    it->handle = SEQ(h);
    it->pos = pos;
    it->state = s;
}

LSQ_HandleT LSQ_CreateSequence(void){
    SeqHandle a = malloc(sizeof(Sequense));
    a->size = 0;
    a->items = NULL;
    return a;
}

void LSQ_DestroySequence(LSQ_HandleT handle){
    SeqHandle a = SEQ(handle);
    if(!a->size){
        free(a->items);
    }
    free(a);
}

LSQ_IntegerIndexT LSQ_GetSize(LSQ_HandleT handle){
    return SEQ(handle)->size;
}

int LSQ_IsIteratorDereferencable(LSQ_IteratorT iterator){
    return ITER(iterator)->state == ITERATOR_NORMAL;
}

int LSQ_IsIteratorPastRear(LSQ_IteratorT iterator){
    return ITER(iterator)->state == ITERATOR_PAST_REAR;
}

int LSQ_IsIteratorBeforeFirst(LSQ_IteratorT iterator){
    return ITER(iterator)->state == ITERATOR_BEFORE_FIRST;
}

LSQ_BaseTypeT* LSQ_DereferenceIterator(LSQ_IteratorT iterator){
    ItHandle it = ITER(iterator);
    return it->handle->items + it->pos;
}

LSQ_IteratorT LSQ_GetElementByIndex(LSQ_HandleT handle, LSQ_IntegerIndexT index){
    return CreateIterator(handle, index, ITERATOR_NORMAL);
}

LSQ_IteratorT LSQ_GetFrontElement(LSQ_HandleT handle){
    return CreateIterator(handle, 0, ITERATOR_NORMAL);
}

LSQ_IteratorT LSQ_GetPastRearElement(LSQ_HandleT handle){
    return CreateIterator(handle, SEQ(handle)->size, ITERATOR_PAST_REAR);
}

void LSQ_DestroyIterator(LSQ_IteratorT iterator){
    free(ITER(iterator));
}

void LSQ_AdvanceOneElement(LSQ_IteratorT iterator){
    LSQ_ShiftPosition(iterator, 1);
}

void LSQ_RewindOneElement(LSQ_IteratorT iterator){
    LSQ_ShiftPosition(iterator, -1);
}

void LSQ_ShiftPosition(LSQ_IteratorT iterator, LSQ_IntegerIndexT shift){
    ItHandle it = ITER(iterator);
    it->pos += shift;
    it->state =
        it->pos < 0 ? ITERATOR_BEFORE_FIRST :
        it->pos >= it->handle->size ? ITERATOR_PAST_REAR : ITERATOR_NORMAL;
}

void LSQ_SetPosition(LSQ_IteratorT iterator, LSQ_IntegerIndexT pos){
    ITER(iterator)->pos = pos;
}

void LSQ_InsertFrontElement(LSQ_HandleT handle, LSQ_BaseTypeT element){
    SeqHandle h = SEQ(handle);
    Resize(h, 1);
    ShiftMemory(h->items, h->size - 1, 1);
    h->items[0] = element;
}

void LSQ_InsertRearElement(LSQ_HandleT handle, LSQ_BaseTypeT element){
    SeqHandle h = SEQ(handle);
    Resize(h, -1);
    h->items[h->size - 1] = element;
}

void LSQ_InsertElementBeforeGiven(LSQ_IteratorT iterator, LSQ_BaseTypeT newElement){
    ItHandle it = ITER(iterator);
    Resize(it->handle, 1);
    ShiftMemory(it->handle->items + it->pos, it->handle->size - it->pos - 1, 1);
    it->handle->items[it->pos] = newElement;
}

void LSQ_DeleteFrontElement(LSQ_HandleT handle){
    SeqHandle h = SEQ(handle);
    ShiftMemory(h->items, h->size, -1);;
    Resize(h, -1);
}

void LSQ_DeleteRearElement(LSQ_HandleT handle){
    Resize(SEQ(handle), -1);
}

void LSQ_DeleteGivenElement(LSQ_IteratorT iterator){
    ItHandle it = ITER(iterator);
    ShiftMemory(it->handle->items + it->pos + 1, it->handle->size - it->pos, -1);
    Resize(it->handle, -1);
}

кто списал, тот сдохнет