@Override
  public void toStream(final DependencyContext context, final PrintStream stream) {
    super.toStream(context, stream);

    stream.print("      Superclass : ");
    stream.println(mySuperClass.getDescr(context));

    stream.print("      Interfaces : ");
    final TypeRepr.AbstractType[] is = myInterfaces.toArray(TypeRepr.AbstractType.EMPTY_TYPE_ARRAY);
    Arrays.sort(is, Comparator.comparing(o -> o.getDescr(context)));
    for (final TypeRepr.AbstractType t : is) {
      stream.print(t.getDescr(context));
      stream.print(" ");
    }
    stream.println();

    stream.print("      Targets    : ");
    final ElemType[] es = myAnnotationTargets.toArray(new ElemType[0]);
    Arrays.sort(es);
    for (final ElemType e : es) {
      stream.print(e);
      stream.print("; ");
    }
    stream.println();

    stream.print("      Policy     : ");
    stream.println(myRetentionPolicy);

    stream.print("      Outer class: ");
    stream.println(context.getValue(myOuterClassName));

    stream.print("      Local class: ");
    stream.println(myIsLocal);
    stream.print("      Anonymous class: ");
    stream.println(myIsAnonymous);
    stream.print("      Has inlined constants: ");
    stream.println(myHasInlinedConstants);
    stream.print("      IsGenerated: ");
    stream.println(myIsGenerated);

    stream.println("      Fields:");
    final FieldRepr[] fs = myFields.toArray(new FieldRepr[0]);
    Arrays.sort(fs, (o1, o2) -> {
      if (o1.name == o2.name) {
        return o1.myType.getDescr(context).compareTo(o2.myType.getDescr(context));
      }

      return Objects.requireNonNull(context.getValue(o1.name)).compareTo(Objects.requireNonNull(context.getValue(o2.name)));
    });
    for (final FieldRepr f : fs) {
      f.toStream(context, stream);
    }
    stream.println("      End Of Fields");

    stream.println("      Methods:");
    final MethodRepr[] ms = myMethods.toArray(new MethodRepr[0]);
    Arrays.sort(ms, (o1, o2) -> {
      if (o1.name == o2.name) {
        final String d1 = o1.myType.getDescr(context);
        final String d2 = o2.myType.getDescr(context);

        final int c = d1.compareTo(d2);

        if (c == 0) {
          final int l1 = o1.myArgumentTypes.length;
          final int l2 = o2.myArgumentTypes.length;

          if (l1 == l2) {
            for (int i = 0; i<l1; i++) {
              final String d11 = o1.myArgumentTypes[i].getDescr(context);
              final String d22 = o2.myArgumentTypes[i].getDescr(context);

              final int cc = d11.compareTo(d22);

              if (cc != 0) {
                return cc;
              }
            }

            return 0;
          }

          return l1 -l2;
        }

        return c;
      }

      return Objects.requireNonNull(context.getValue(o1.name)).compareTo(Objects.requireNonNull(context.getValue(o2.name)));
    });
    for (final MethodRepr m : ms) {
      m.toStream(context, stream);
    }
    stream.println("      End Of Methods");

    stream.println("      Usages:");

    final List<String> usages = new LinkedList<>();

    for (final UsageRepr.Usage u : getUsages()) {
      final ByteArrayOutputStream bas = new ByteArrayOutputStream();

      u.toStream(myContext, new PrintStream(bas));

      try {
        bas.close();
      }
      catch (final IOException e) {
        throw new BuildDataCorruptedException(e);
      }

      usages.add(bas.toString());
    }

    Collections.sort(usages);

    for (final String s : usages) {
      stream.println(s);
    }

    stream.println("      End Of Usages");
  }
@Override
  public void toStream(final DependencyContext context, final PrintStream stream)