#pragma implementation
#include "strlist.h"

struct StringList::Slist {
  Slist *next, *prev;
  Slist() { next = prev = this; }
  ~Slist() { next->prev = prev; prev->next = next; }
  void insert(Slist *p) {
    p->next = this;
    p->prev = prev;
    prev->next = p;
    prev = p;
  }
  string txt;
};

StringList::StringList() {
  cnt = 0;
  head = cur = 0;
}

StringList::~StringList() {
  clear();
}

void StringList::clear() {
  while (cnt) {
    --cnt;
    cur = head->next;
    delete head;
    head = cur;
  }
  head = cur = 0;
}

StringList::Slist *StringList::find(int i) {
  if (i < 0) i += cnt;
  if (i < 0 || i >= cnt) return 0;
  int ncnt = mod(i - idx);
  int pcnt = mod(idx - i);
  int nncnt = (i < ncnt) ? i : ncnt;
  int ppcnt = (cnt - i < pcnt) ? cnt - i : pcnt;
  if (nncnt < ppcnt) {
    if (nncnt < ncnt) {
      idx = 0;
      cur = head;
    }
    while (i != idx) {
      cur = cur->next;
      idx = mod(idx + 1);
    }
  }
  else {
    if (ppcnt < pcnt) {
      idx = cnt - 1;
      cur = head->prev;
    }
    while (i != idx) {
      cur = cur->prev;
      idx = mod(idx - 1);
    }
  }
  return cur;
}

string &StringList::operator[](int i) {
  return find(i) ? cur->txt : def;
}

string &StringList::insertln(int i) {
  Slist *p = new Slist;
  if (cnt) {
    if (find(i) == 0) {
      ++cnt;
      head->insert(p);	// add to end
      return p->txt;
    }
    cur->insert(p);
  }
  else
    i = idx = 0;
  cur = p;
  if (!i)
    head = p;
  ++cnt;
  return p->txt;
}

void StringList::deleteln(int i) {
  Slist *p = find(i);
  if (p) {
    if (idx >= --cnt) idx = 0;
    if (idx > i) --idx;
    if (p == cur) cur = cur->next;
    if (p == head) head = head->next;
    delete p;
  }
}