import 'dart:mirrors';
import 'rr.dart' as t;

void main(List<String> arguments) {
  var ss = List<int>.filled(1, 0);
  print(ss.runtimeType.runtimeType);
  print(ss.runtimeType.toString());
  print(ss.runtimeType.hashCode);
  var okk1 = reflect(ss.runtimeType);
  print(okk1);
  
  var kk = List.filled(4, 4);
  print(okk1 == reflect(kk.runtimeType));
  print(kk.runtimeType.hashCode);
  print('Hello world!');
  print(reflect(ss).type);
  var uu = List<int>.filled(3, 0, growable: true);
  var st = List<int>.filled(8, 9, growable: true);
  print(reflect(uu).type);
  var okk2 = reflect(uu.runtimeType);
  print(okk2);
  print(okk1 == okk2);
  
  print(uu.runtimeType);
  print(uu.runtimeType.hashCode);
  print(st.runtimeType.hashCode);
  test(4);
  // 证明runtimeType确实可以作为区分类型的key
  // 只是runtimeType.toString()是可能多个类型的输出值是一样的
  // 即_List和_GrowableList都对toString方法进行了重载，然后
  // 都输出的List<..>【当然，这个貌似是编译器内部的一种重载，程序员无法
  // 实现】【不过也可以自己实现，即覆盖runtimeType这个计算属性】
  // 这个自己写代码也是会遇到的，比如两个类型在不同模块里
  // ，但是都叫Uuu，因此他们对象的runtimeType的toString()值是一致的，
  // 但是他们不相等；

  print(ss.runtimeType == uu.runtimeType);
  print(ss.runtimeType == kk.runtimeType);
  print(uu.runtimeType == st.runtimeType);
  print(st.runtimeType == ss.runtimeType);
  var uus = List<double>.filled(3, 8, growable: true);
  print(uus.runtimeType == uu.runtimeType);
  print("------------");
  Umm sss = Umm();
  print(sss.runtimeType);
  print(sss.runtimeType.hashCode);
  Umm sst = Umm<int>();
  print(sst.runtimeType == sss.runtimeType);
  print(sst.runtimeType.hashCode);
  Umm ssss = Umm(s: 4);
  print(ssss.runtimeType == sss.runtimeType);
  print(ssss.runtimeType.hashCode);
  print(reflect(ssss.runtimeType));
  Ukk rrr = Ukk();
  print(rrr.runtimeType);
  print(rrr.runtimeType.hashCode);
  Ukk rrt = Ukk<int>();
  print(rrt.runtimeType);
  print(rrt.runtimeType == rrr.runtimeType);
  print(rrr.runtimeType == sss.runtimeType);
  print(rrr.runtimeType);
  print(sss.runtimeType);
  print(rrr.runtimeType.runtimeType);
  print(sss.runtimeType.runtimeType);
  print(sss.runtimeType.runtimeType.runtimeType);
  print(rrt.runtimeType.hashCode);
  Ukk rrrr = Ukk(s: 4);
  print(rrrr.runtimeType == rrr.runtimeType);
  print(rrrr.runtimeType.hashCode);
  print(reflect(rrrr.runtimeType));
}

void test([int? ss=null]) {
  print(ss);
}

class Umm<T> {  // 模拟_GrowableList
  Type get runtimeType => UmmType.tType<T>();
  int? s;
  Umm({int? s}) {
    this.s = s;
  }
}

class UmmType<T> extends Type {

  static Map<Type, Type> types = Map();

  // M也是Type的一种，注意Type和Class又是不同的
  // 比如extension是Type却不是Class
  // 所有的对象都是Object的子类，而不是所有的类型都是Object的子类
  static Type tType<M>() {
    // 防并发没有，需要补上
    if (types.containsKey(M)) {
      return types[M]!;
    } else {
      types[M] = UmmType<M>();
      return types[M]!;
    }
  }

  @override
  String toString() {
    // T 在这里是T实际类型对象的runtimeType值
    return "Lost<" + T.toString() + ">";
  }
}

class Ukk<T> {  // 模拟_List
  // 只要两个Type的定义是在不同的文件里，则是可以同名的
  // 同名不代表同类型；
  Type get runtimeType => t.UmmType.tType<T>();
  int? s;
  Ukk({int? s}) {
    this.s = s;
  }
}

class UkkType<T> extends Type {

  static Map<Type, Type> types = Map();

  // M也是Type的一种，注意Type和Class又是不同的
  // 比如extension是Type却不是Class
  // 所有的对象都是Object的子类，而不是所有的类型都是Object的子类
  static Type tType<M>() {
    // 防并发没有，需要补上
    if (types.containsKey(M)) {
      return types[M]!;
    } else {
      types[M] = UkkType<M>();
      return types[M]!;
    }
  }

  @override
  String toString() {
    return "Lost<" + T.toString() + ">";
  }
}