Kotlinで双方向連結リストを実装したい。特にGetEnumeratorと型引数Tらへんに困ってます。

Question

前提・実現したいこと

Kotlinで双方向連結リストを実装したい。
前提として下記サイトを参考にした。
双方向連結リスト - アルゴリズムとデータ構造 | ++C++; // 未確認飛行 C

発生している問題・エラーメッセージ

kotlinc-jvm.bat ".\BidirectionalLinkedList.kt" -include-runtime -d ".\BidirectionalLinkedList.jar"

一旦、上記でコンパイルが通るよう修正しました。
新たな問題点は3点。（編集前の4点は保留）
(5)(4)とほぼ同義だが、型引数Tの指定方法がよくわからない。とりあえずAny？に変更した。
(6)NodeクラスもBidirectionalLinkedListIteratorクラスもBidirectionalLinkedListにだけ見えるようにしたいが、単純に内部クラスにしてしまうと、～IteratorクラスからNodeクラスが見えない。
(7)IteratorとかIterableの継承方法がよくわからない。

該当のソースコード

//https://ufcpp.net/study/algorithm/col_blist.html

package Collections;


///<summary>
/// 双方向連結リスト。
///</summary>
///<typeparam name = "T">要素の型</typeparam>
public class BidirectionalLinkedList {

	//#region フィールド

	public val dummy: Node;
	public var count: Int;

	//#endregion

	//#region 初期化

	public constructor() {
		this.dummy = Node(null, null, null);
		this.dummy.Next = this.dummy;
		this.dummy.Previous = this.dummy;
		this.count = 0;
	}

	//#endregion

	//#region プロパティ

	public val First: Node?
		get() = this.dummy.Next;

	public val Last: Node?
		get() = this.dummy.Previous;

	///<summary>
	/// リストの終端（末尾よりも後ろの番兵に当たるノード）。
	///</summary>
	public val End: Node?
		get() = this.dummy;

	//#endregion

	//#region 挿入・削除

	///<summary>
	/// ノード n の後ろに新しい要素を追加。
	///</summary>
	///<param name = "e">新しい要素</param>
	///<param name = "n">要素の挿入位置</param>
	///<returns>新しく挿入されたノード</returns>
	public fun InsertEAfterN(e: Any?, n: Node?): Node? {
		val m: Node? = Node(e, n, n?.Next);
		n?.Next?.Previous = m;
		n?.Next = m;
		this.count++;
		return m;
	}

	///<summary>
	/// ノード n の前に新しい要素を追加。
	///</summary>
	///<param name = "e">新しい要素</param>
	///<param name = "n">要素の挿入位置</param>
	///<returns>新しく挿入されたノード</returns>
	public fun InsertEBeforeN(e: Any?, n: Node?): Node? {
		val m: Node? = Node(e, n?.Previous, n);
		n?.Previous?.Next = m;
		n?.Previous = m;
		this.count++;
		return m;
	}

	///<summary>
	/// 先頭に新しい要素を追加。
	///</summary>
	///<param name = "elem">新しい要素</param>
	///<returns>新しく挿入されたノード</returns>
	public fun InsertFirst(elem: Any?): Node? {
		return this.InsertEAfterN(elem, this.dummy);
	}

	///<summary>
	/// 末尾に新しい要素を追加。
	///</summary>
	///<param name = "elem">新しい要素</param>
	///<returns>新しく挿入されたノード</returns>
	public fun InsertLast(elem: Any?): Node? {
		return this.InsertEBeforeN(elem, this.dummy);
	}

	///<summary>
	/// ノード n 自身を削除。
	///</summary>
	///<param name = "n">要素の削除位置</param>
	///<returns>削除した要素の次のノード</returns>
	public fun Erase(n: Node?): Node? {
		if (n == this.dummy) {
			return this.dummy;
		}
		n?.Previous?.Next = n?.Next;
		n?.Next?.Previous = n?.Previous;
		this.count--;
		return n?.Next;
	}

	///<summary>
	/// 先頭の要素を削除。
	///</summary>
	public fun EraseFirst(): Unit {
		this.Erase(this.First);
	}

	///<summary>
	/// 末尾の要素を削除。
	///</summary>
	public fun EraseLast(): Unit {
		this.Erase(this.Last);
	}

	//#endregion

	//#region IEnumerable<T>メンバ

	operator fun iterator() = BidirectionalLinkedListIterator(this);

	//#endregion

}

public class BidirectionalLinkedListIterator(val list: BidirectionalLinkedList) {
	private var n: Node? = list.First;
	fun next(): Node? {
		return n?.Next;
	}
	fun hasNext(): Boolean {
		return n != list.End;
	}
}

///<summary>
/// 連結リストのノード。
///</summary>
public class Node {

	//#region フィールド

	private var value: Any?;
	private var prev: Node?;
	private var next: Node?;

	//#endregion

	//#region 初期化

	internal constructor(_value: Any?, _prev: Node?, _next: Node?) {
		this.value = _value;
		this.prev = _prev;
		this.next = _next;
	}

	//#endregion

	//#region プロパティ

	public var Value: Any?
		get() = this.value;
		set(value) {
			this.value = value;
		}

	/// <summary>
	/// 前のノード。
	/// </summary>
	var Previous: Node?
		get() = this.prev;
		internal set(value) {
			this.prev = value;
		}

	/// <summary>
	/// 次のノード。
	/// </summary>
	var Next: Node?
		get() = this.next;
		internal set(value) {
			this.next = value;
		}

	//#endregion

}

試したこと

(1)Kotlinで調べても全然情報が見つからないため、主にjavaで調べたのですが、GetEnumeratorなどの実装例が見つからず断念。
Iteratorを試そうとしたが、現在のNode？の指定方法や初期化が不明なために断念。とりあえずコメントアウト。
(2)他作クラスがどこにあるのかわからず、クラスパス？へ設定できずimportも保留。
(4)Kotlinの和訳リファレンスやネットで使用例などを見る限り、型引数の使い方も間違ってなさそうに見えるがダメらしい。

補足情報（FW/ツールのバージョンなど）

・kotlincは1.3.60

Answer 1

可視性修飾子をちゃんと最低限にしたり、いきなりNodeクラスにするのではなくNodeクラスを継承したBidirectionalNodeクラスとしたかったり、色々思うところはありますが、とりあえず動作確認までできました。

コマンドプロンプト

kotlinc-jvm.bat Node.kt -d Node.jar
kotlinc-jvm.bat BidirectionalLinkedList.kt -cp ".\Node.jar" -d BidirectionalLinkedList.jar
kotlinc-jvm.bat test.kt -cp ".\Node.jar;.\BidirectionalLinkedList.jar" -include-runtime -d test.jar
java -cp ".\Node.jar;.\BidirectionalLinkedList.jar;.\test.jar" TestKt

Node.kt

//https://ufcpp.net/study/algorithm/col_blist.html

//package Collections;

///<summary>
/// 連結リストのノード。
///</summary>
///<typeparam name = "T">要素の型</typeparam>
public class Node<T> {

	//#region フィールド
	private var value: T;
	private var prev: Node<T>;
	private var next: Node<T>;
	//#endregion

	//#region 初期化
	constructor(_value: T, _prev: Node<T>?, _next: Node<T>?) {
		this.value = _value;
		this.prev = _prev?:this;
		this.next = _next?:this;
	}
	//#endregion

	//#region プロパティ

	public var Value: T
		get() = this.value;
		set(value) {
			this.value = value;
		}

	/// <summary>
	/// 前のノード。
	/// </summary>
	var Previous: Node<T>
		get() = this.prev;
//		internal set(value) {
		set(value) {
			this.prev = value;
		}

	/// <summary>
	/// 次のノード。
	/// </summary>
	var Next: Node<T>
		get() = this.next;
//		internal set(value) {
		set(value) {
			this.next = value;
		}

	//#endregion

}

BidirectionalLinkedList.kt

//https://ufcpp.net/study/algorithm/col_blist.html

//package Collections;

interface Iterator<T> {
	operator fun hasNext() : Boolean
	operator fun next() : Node<T>
}
interface Aggregate<T> {
	operator fun iterator() : Iterator<T>
}

///<summary>
/// 双方向連結リスト。
///</summary>
///<typeparam name = "T">要素の型</typeparam>
public class BidirectionalLinkedList<T> : Aggregate<T> {

	//#region フィールド
	public val dummy: Node<T>;
	public var count: Int;
	//#endregion

	//#region 初期化
	public constructor(init: T) {
		this.dummy = Node<T>(init, null, null);
		this.dummy.Next = this.dummy;
		this.dummy.Previous = this.dummy;
		this.count = 0;
	}
	//#endregion

	//#region プロパティ

	public val First: Node<T>
		get() = this.dummy.Next;

	public val Last: Node<T>
		get() = this.dummy.Previous;

	///<summary>
	/// リストの終端（末尾よりも後ろの番兵に当たるノード）。
	///</summary>
	public val End: Node<T>
		get() = this.dummy;

	//#endregion

	//#region メソッド

	///<summary>
	/// ノード n の後ろに新しい要素を追加。
	///</summary>
	///<param name = "e">新しい要素</param>
	///<param name = "n">要素の挿入位置</param>
	///<returns>新しく挿入されたノード</returns>
	public fun InsertEAfterN(e: T, n: Node<T>): Node<T> {
		val m: Node<T> = Node<T>(e, n, n.Next);
		n.Next.Previous = m;
		n.Next = m;
		this.count++;
		return m;
	}

	///<summary>
	/// ノード n の前に新しい要素を追加。
	///</summary>
	///<param name = "e">新しい要素</param>
	///<param name = "n">要素の挿入位置</param>
	///<returns>新しく挿入されたノード</returns>
	public fun InsertEBeforeN(e: T, n: Node<T>): Node<T> {
		val m: Node<T> = Node<T>(e, n.Previous, n);
		n.Previous.Next = m;
		n.Previous = m;
		this.count++;
		return m;
	}

	///<summary>
	/// 先頭に新しい要素を追加。
	///</summary>
	///<param name = "e">新しい要素</param>
	///<returns>新しく挿入されたノード</returns>
	public fun InsertFirst(e: T): Node<T> {
		return this.InsertEAfterN(e, this.dummy);
	}

	///<summary>
	/// 末尾に新しい要素を追加。
	///</summary>
	///<param name = "e">新しい要素</param>
	///<returns>新しく挿入されたノード</returns>
	public fun InsertLast(e: T): Node<T> {
		return this.InsertEBeforeN(e, this.dummy);
	}

	///<summary>
	/// ノード n 自身を削除。
	///</summary>
	///<param name = "n">要素の削除位置</param>
	///<returns>削除した要素の次のノード</returns>
	public fun Erase(n: Node<T>): Node<T> {
		if (n == this.dummy) {
			return this.dummy;
		}
		n.Previous.Next = n.Next;
		n.Next.Previous = n.Previous;
		this.count--;
		return n.Next;
	}

	//#endregion

	//#region interfaceの実装
	public override fun iterator(): Iterator<T> {
		return BidirectionalLinkedListIterator<T>(this);
	}

	public class BidirectionalLinkedListIterator<T>(val list: BidirectionalLinkedList<T>) : Iterator<T>{
		private var n: Node<T> = list.End;
		override fun next(): Node<T> {
			n = n.Next;
			return n;
		}
		override fun hasNext(): Boolean {
			return n.Next !== list.End;
		}
	}
	//#endregion

}

test.kt

fun main(args: Array<String>) {
	println("----Float----\n");

	var blly: BidirectionalLinkedList<Float> = BidirectionalLinkedList<Float>(1.5F);
	println("count: "+blly.count);//0
	println("----for start----");
	for (ny: Node<Float> in blly) {
		println(ny.Value);
	}
	println("----for end----\n");
	blly.InsertFirst(1F);
	println("count: "+blly.count);//1
	println("----for start----");
	for (ny: Node<Float> in blly) {
		println(ny.Value);
	}
	println("----for end----\n");
	var n2y: Node<Float> = blly.InsertLast(2F);
	println(n2y.Value);//2
	println("count: "+blly.count);//2
	println("----for start----");
	for (ny: Node<Float> in blly) {
		println(ny.Value);//1,2
	}
	println("----for end----\n");
	blly.InsertEBeforeN(1.5F,n2y);
	println("count: "+blly.count);//3
	println("----for start----");
	for (ny: Node<Float> in blly) {
		println(ny.Value);//1,1.5,2
	}
	println("----for end----\n");

	println("\n\n\n");

	println("----Int?----\n");

	var blln: BidirectionalLinkedList<Int?> = BidirectionalLinkedList<Int?>(null);
	println("count: "+blln.count);//0
	println("----for start----");
	for (nn: Node<Int?> in blln) {
		println(nn.Value?: "nullです");
	}
	println("----for end----\n");
	blln.InsertFirst(1);
	println("count: "+blln.count);//1
	println("----for start----");
	for (nn: Node<Int?> in blln) {
		println(nn.Value?: "nullです");
	}
	println("----for end----\n");
	var n2n: Node<Int?> = blln.InsertLast(2);
	println(n2n.Value?: "nullです");//2
	println("count: "+blln.count);//2
	println("----for start----");
	for (nn: Node<Int?> in blln) {
		println(nn.Value?: "nullです");//1,2
	}
	println("----for end----\n");
	blln.InsertEBeforeN(null,n2n);
	println("count: "+blln.count);//3
	println("----for start----");
	for (nn: Node<Int?> in blln) {
		println(nn.Value?: "nullです");//1,nullです,2
	}
	println("----for end----\n");
	blln.Erase(n2n);
	println("count: "+blln.count);//2
	println("----for start----");
	for (nn: Node<Int?> in blln) {
		println(nn.Value?: "nullです");//1,nullです
	}
	println("----for end----\n");
	blln.Erase(blln.First);
	println("count: "+blln.count);//1
	println("----for start----");
	for (nn: Node<Int?> in blln) {
		println(nn.Value?: "nullです");//nullです
	}
	println("----for end----\n");
	blln.Erase(blln.Last);
	println("count: "+blln.count);//0
	println("----for start----");
	for (nn: Node<Int?> in blln) {
		println(nn.Value?: "nullです");//
	}
	println("----for end----\n");
}

Answer 2

→(1)GetEnumerator周辺の実装方法がわからない

実装できません

→(2)System.Collections.Genericのインポート方法がわからない

インポートできません

→(3)上のインポートができれば解決するはず。。。

インポートできないので解決しません

→(4)全般的に型引数Tが参照できない

inner class にしてください

C#のコードをもとにkotlinを書きたいのであれば、C#上での動作を理解したうえでkotlinでそれを再現するしかありません。kotlinでの書き方がわからないからといってC#のコードをそのまま持ってきて穴埋めするのでは動くわけありません。

Comments

[picohead]

ご回答ありがとうございます。
C#のコードを元にはできないのですね。。。
私はKotlinで双方向連結リストを実装したいのであって、C#を元にしたいわけではないのでそこは諦めます。
KotlinでもMutableListなどのリストが使用できます。あれはどのように実装されているのでしょうか。
あれもfor(A in B)でループできて、型引数を渡しているため、あれがわかれば私が詰まってるとこがちょうど解決できる見込みです。

[yudedako67]

Iterableを実装して、Iteratorを実装したオブジェクトを返すようにすればできます。