Range.clcl

class Range<T:IIteratorable>
{
    include MObjectBase;

    head:T;
    tail:T;

    def initialize() {}

    def initialize(head:T, tail:T) {
        self.head = head;
        self.tail = tail
    }

    def clone(): Range<T> {
        result := Range<T>();

        if(self.head.identifyWith(null).negative()) {
            result.head = self.head.clone();
        }
        if(self.tail.identifyWith(null).negative()) {
            result.tail = self.tail.clone();
        }

        return result;
    }

    def equals(right:Range<T>):bool {
        return self.head.equals(right.head) && self.tail.equals(right.tail);
    }

    def isMember(value:T):bool {
        return value.compare(self.head) >= 0 && value.compare(self.tail) < 0;
    }

    def toString(): String {
        return "Range";
    }

    def compare(range:Range<T>): int {
        head_cmp := self.head.compare(range.head);
        tail_cmp := self.tail.compare(range.tail);

        if(head_cmp == 0 && tail_cmp == 0) {
            return 0;
        }
        elif(head_cmp == -1 && (tail_cmp == 0 || tail_cmp == -1)) {
            return -1;
        }
        else {
            return 1;
        }
    }

    def add(right:Range<T>):Range<T> {
        result := self.clone();
        result.head = result.head.add(right.head);
        result.tail = result.tail.add(right.tail);
        return result;
    }

    def toSortableList(): SortableList<T> {
        result := SortableList<T>();

        for(p:=self.head(); p.compare(self.tail) < 0; p = p.next()) {
            result.add(p);
        }

        return result;
    }

    def toList(): List<T> {
        result := List<T>();

        for(p:=self.head(); p.compare(self.tail) < 0; p = p.next()) {
            result.add(p);
        }

        return result;
    }

    def toEqualableList(): EqualableList<T> {
        result := EqualableList<T>();

        for(p:=self.head(); p.compare(self.tail) < 0; p = p.next()) {
            result.add(p);
        }

        return result;
    }
}

module MListWithRange
{
    def subList(range:Range<Integer>):SELF<T> {
        return self.subList(range.head.value, range.tail.value);
    }

    def deleteWithRange(range:Range<Integer>):SELF<T> {
        return self.deleteWithRange(range.head.value, range.tail.value);
    }

    def fill(range:Range<Integer>, item:T):SELF<T> {
        return self.fill(range.head.value, range.tail.value, item);
    }
}

inherit List <T:Object>
{
    include MListWithRange;
}

inherit EqualableList<T:IEqualable>
{
    include MListWithRange;
}

inherit SortableList<T:ISortable>
{
    include MListWithRange;
}

inherit String 
{
    def subString(range:Range<Integer>):  String {
        return self.subString(range.head.value, range.tail.value);
    }
    def delete(range:Range<Integer>): String {
        return self.delete(range.head.value, range.tail.value);
    }
}

inherit Buffer
{
    def subBuffer(range:Range<Integer>): Buffer {
        return self.subBuffer(range.head.value, range.tail.value);
    }
}