/* 
    v.1.1
    Библиотека, описывающая списки - массивы с неопределенным размером (максимальный 8192, это ограничение массива структур)
    Список - последовательность элементов, каждый элемент имеет кокнкретное значение и ссылку на следующий.
    Головой называют первый элемент списка, хвостом все остальные. При операции удаления, добавления головы нужно не забывать
    переназначать переменную, в которой хранится голова. Пример использования:
    realList L = realList.Create(23)
    L.AddTail(42)
    L = L.AddHead(16) или ListAddHead(L,15)
    
    Для работы необходим cJass v1.4 или выше. 
    
    Особые благодарности проекту XGM. ©NCrashed 2009
*/
library ListLib { 

#include "cj_types_priv.j"

define {
        ListAddHead(list,m) = list = list.AddHead(m) // для тех кто забывает переназначить голову списка
        ListDelHead(list) = list = list.DelHead()
        
        DefineOfList(type) = { // общие функции для всех списков
            
            static type##List Create(type m) { // создает список с 1 элементом k
                type##List L = type##List.create()
                L.k = m
                return L
            }
            
            type##List AddHead(type m) { // добавление в голову списка, обязательно надо переназначить голову!! list = list.AddHead(m)
                type##List L = type##List.Create(m)
                L.next = this
                return L
            }
    
            void AddTail(type m) { // Добавление в хвост списка
                type##List L = type##List.Create(m)
                while ( this.next != null) {this = this.next}
                this.next = L
            }
    
            type Head() { // Возвращает значение головы списка
                return this.k
            }
        
            type Last() { // Возвращает значение последнего элемента списка
                while ( this.next != null) {this = this.next}
                return this.k
            }
    
            type##List Begin() { // Создает список, в который копируются все элементы кроме последнего
                if this.next == 0 {return 0} 
                type##List h = type##List.Create(this.k)
                this = this.next
                type##List Result = h
                while (this.next != null) {
                    type##List L = type##List.Create(this.k)
                    h.next = L
                    h = L
                    this = this.next
                }
                return Result
            }
    
            type##List Tail() { // Создает список, в который копируются все элементы кроме первого
                if this.next == 0 {return 0}
                type##List h = type##List.Create(this.next.k)
                this = this.next.next
                type##List Result = h
                while (this != null) {
                    type##List L = type##List.Create(this.k)
                    h.next = L
                    h = L
                    this = this.next
                }
                return Result 
            }
    
            type##List Copy() { // Создает список, в который копируются все элементы из старого
                type##List h = type##List.Create(this.k)
                this = this.next
                type##List Result = h
                while (this != null) {
                    type##List L = type##List.Create(this.k)
                    h.next = L
                    h = L
                    this = this.next
                }
                return Result 
            }
        
            int Length() { // Возвращает длину списка
                int Result = 0
                while (this != null) { this = this.next; Result++ }
                return Result
            }
        
            bool Member(type m) { // Возвращает тру, если элемент m есть в списке
                while (this != null) {if this.k == m {return true};this=this.next}
                return false
            }
            
            bool DelElement(type m) { // Удаляет первый элемент m
                if this.Head() == m {ListDelHead(this);return true}
                while (this.next != 0) {
                    if this.next.k == m {
                        type##List h = this.next
                        this.next = this.next.next
                        h.destroy()
                        return true
                    }
                    this=this.next
                }
                return false
            }
            
            type##List DelHead() { // Удаляет голову
                type##List L = this.next
                if this != 0 {this.destroy()}
                return L
            }
            
            void DelTail() { // Удаляет последний элемент
                while ( this.next.next != null) {this = this.next}
                if this != null {this.next.destroy();this.next = 0}
            }
            
            void Destroy() { //Уничтожение списка
                type##List L
                while (this != null) {
                        L = this; this = this.next
                        L.next = 0
                        #if type == int
                            L.k = 0
                        #elseif type == real 
                            L.k = 0.
                        #else
                            L.k = null
                        #endif
                        L.destroy()
                }
            }        
        }
}

// Общая схема создания списка для типа type
//struct typeList {
//    type k = 0
//    typeList next = 0
//
//    DefineOfList(type)
//
//    Далее ваши методы
//}

// Наиболее часто употребляемые списки
struct integerList {
    int k = 0 // значение элемента
    integerList next = 0 // ссылка на следующий элемент

    DefineOfList(int) // вызов макроса, который определяет стандартные действия
    
    #if DEBUG // Для дебага списка, вставляется только, когда стоит галка JassHelper->Debug Mode
        void DBPrint() {
            ClearTextMessages()
            while (this != null) {
                BJDebugMsg(I2S(this.k))
                this = this.next
            }
        }
    #endif
}

struct realList {
    real k = 0.
    realList next = 0

    DefineOfList(real)
    
    #if DEBUG 
        void DBPrint() {
            ClearTextMessages()
            while (this != null) {
                BJDebugMsg(R2S(this.k))
                this = this.next
            }
        }
    #endif
}

struct unitList {
    unit k = null
    unitList next = 0
    
    DefineOfList(unit)
    
    #if DEBUG 
        void DBPrint() {
            ClearTextMessages()
            while (this != null) {
                BJDebugMsg(GetUnitName(this.k)+" ("+R2S(GetUnitX(this.k))+","+R2S(GetUnitY(this.k))+")")
                this = this.next
            }
        }
    #endif
}

struct destructableList {
    destructable k = null
    destructableList next = 0
    
    DefineOfList(destructable)
}

struct timerList {
    timer k = null
    timerList next = 0
    
    DefineOfList(timer)
}


}