#ifndef DONT_INSTANTIATE
#include "musicmud.h"
#include "World.h"
#include "Library.h"
#include "Interpret.h"
#include "State.h"
#endif

template <class T> World<T>::World() {
  array_size = 16;
  used_size = 0;
  planet = 0;
}

template <class T> World<T>::World(const World &a) {
  array_size = a.array_size;
  used_size = a.used_size;
  if (a.planet) {
    planet = (T**)malloc(sizeof(T *)*array_size);
    memcpy(planet, a.planet, sizeof(T *)*array_size);
  } else {
    planet = 0;
  }
}

template <class T> void World<T>::operator=(const World &a) {
  if (planet)
    free(planet);

  array_size = a.array_size;
  used_size = a.used_size;
  if (a.planet) {
    planet = (T**)malloc(sizeof(T *)*array_size);
    memcpy(planet, a.planet, sizeof(T *)*array_size);
  } else {
    planet = 0;
  }
}

template <class T> World<T>::~World() {
  if (planet)
    free(planet);
}

template <class T> int World<T>::getsize() const {
  return used_size;
}

template <class T> bool World<T>::contains(T *w) const {
  return get(w->id);
}

template <class T> T* World<T>::get_nth(int i) const {
  return planet[i];
}

template <class T> T* World<T>::get(int i) const {
  return planet[i];
}

template <class T> T* World<T>::get(const char *tag) const {
  return rawget(tag);
}

template <class T> T* World<T>::rawget(const char *tag) const {
  if (!planet) {
    return 0;
  }
  
  if (!tag) return 0;
  if (used_size==0) return 0;
  int min = 0, max = used_size;
  int oldmed = -1;
  while (true) 
    {
      int med = (min + max) / 2;
      if (med >= used_size) med--;
      if (med == oldmed) {
	return 0;
      }
      oldmed = med;
      int comp = strcmpn(planet[med]->id, tag);
      if (!comp) {
	return planet[med];
      } else if (comp>0) {
	min = med + 1;
      } else if (comp<0) {
	max = med - 1;
      }
    }
  
  return 0;
}

template <class T> void World<T>::remove(const T &what) {
  int i, shuffle = 0;
  if (!planet) {
    return;
  }
  if (used_size==1) {
    used_size = 0;
    return;
  }
  for (i=0;i<used_size;i++) {
    if (&what == planet[i])
      shuffle = 1;
    if (shuffle) {
      planet[i] = planet[i+1];
    }
  }
  if (shuffle) 
    used_size--;
  
  if (used_size==0) {
    free(planet);
  }
}

template <class T> void World<T>::add(T &what) {
  if (!planet) {
    planet = (T **)malloc(sizeof(T *)*array_size);
  }  
  if (used_size==array_size) {
    T **newp = (T **)realloc(planet, array_size*2*(sizeof(T*)));
    if (!newp) {
      printf("Eep!\n");
      terminate();
    }
    planet = newp;
    array_size *= 2;
  }
  int pos = used_size;
  while (pos) {
    if (strcmpn(what.id, planet[pos-1]->id)<0)
      break;
    planet[pos] = planet[pos-1];
    pos--;
  }
  planet[pos] = &what;
  used_size++;
}

#ifndef DONT_INSTANTIATE
template World<MudObject>;
template World<Player>;
template World<Library>;
template World<Interpreter>;
template World<State>;
template World<Verb>;
#endif