return annotate (m_aType.owner ().ref (clazz));
  }

  @Nonnull
  public <W extends IJAnnotationWriter <?>> W annotate2 (@Nonnull final Class <W> clazz)
  {
    return TypedAnnotationWriter.create (clazz, this);
  }

  /**
   * {@link IJAnnotatable#annotations()}
   */
  @Nonnull
  public Collection <JAnnotationUse> annotations ()
  {
    if (m_aAnnotations == null)
      m_aAnnotations = new ArrayList <JAnnotationUse> ();
    return Collections.unmodifiableList (m_aAnnotations);
  }

    return annotate (m_aType.owner ().ref (clazz));
  }

  @Nonnull
  public <W extends IJAnnotationWriter <?>> W annotate2 (@Nonnull final Class <W> clazz)
  {
    return TypedAnnotationWriter.create (clazz, this);
  }

  /**
   * {@link IJAnnotatable#annotations()}
   */
  @Nonnull
  public Collection <JAnnotationUse> annotations ()
  {
    if (m_aAnnotations == null)

    return annotate (owner ().ref (clazz));
  }

  @Nonnull
  public <W extends IJAnnotationWriter <?>> W annotate2 (@Nonnull final Class <W> clazz)
  {
    return TypedAnnotationWriter.create (clazz, this);
  }

  @Nonnull
  public Collection <JAnnotationUse> annotations ()
  {
    if (m_aAnnotations == null)

    if (m_aAnnotations == null)
      m_aAnnotations = new ArrayList <JAnnotationUse> ();
    final JAnnotationUse a = new JAnnotationUse (clazz);
    m_aAnnotations.add (a);
    return a;
  }

  /**
   * Adds an annotation to this variable.
   *
   * @param clazz
   *        The annotation class to annotate the field with
   */
  @Nonnull
  public JAnnotationUse annotate (@Nonnull final Class <? extends Annotation> clazz)
  {
    return annotate (m_aType.owner ().ref (clazz));

  }

  @Nonnull
  public <W extends IJAnnotationWriter <?>> W annotate2 (@Nonnull final Class <W> clazz)
  {
    return TypedAnnotationWriter.create (clazz, this);
  }

  @Nonnull
  public Collection <JAnnotationUse> annotations ()
  {
    if (m_aAnnotations == null)

  public void write (@Nonnull final char [] buf, @Nonnegative final int off, @Nonnegative final int len) throws IOException
  {
    for (int i = 0; i < len; i++)
      write (buf[off + i]);
  }

  @Override
  public void write (@Nonnull final char [] buf) throws IOException

  }

  @Nonnull
  public JAnnotationUse annotate (@Nonnull final AbstractJClass clazz)
  {
    if (m_aAnnotations == null)
      m_aAnnotations = new ArrayList <JAnnotationUse> ();
    final JAnnotationUse a = new JAnnotationUse (clazz);
    m_aAnnotations.add (a);
    return a;
  }

  @Nonnull
  public <W extends IJAnnotationWriter <?>> W annotate2 (@Nonnull final Class <W> clazz)

  {
    private static final BitSet ESCAPE = new BitSet (128);

    static
    {
      for (int i = 0; i < 0x20; i++)
        if (i != '\t' && i != '\r' && i != '\n')
          ESCAPE.set (i, true);
    }

    return this;
  }

  /**
   * Adds a new annotation to the array.
   */
  @Nonnull
  public JAnnotationUse annotate (@Nonnull final Class <? extends Annotation> clazz)
  {
    return annotate (owner ().ref (clazz));
  }

  /**
   * Adds a new annotation to the array.
   */
  @Nonnull
  public JAnnotationUse annotate (@Nonnull final AbstractJClass clazz)
  {

  public Iterator <AbstractJClass> _implements ()
  {
    return Collections.<AbstractJClass> emptyList ().iterator ();
  }

  @Override
  public boolean isInterface ()
  {
    return false;
  }

  @Override
  public boolean isAbstract ()
  {
    return false;
  }

  @Override

                          aClassToBeWritten.fullName () +
                          ")");

    AbstractJClass aRealReference = aReference;
    if (aRealReference instanceof JAnonymousClass)
    {
      // get the super class of the anonymous class
      aRealReference = ((JAnonymousClass) aRealReference)._extends ();
    }
    if (aRealReference instanceof JNarrowedClass)
    {
      // Remove the generic arguments
      aRealReference = aRealReference.erasure ();
    }

    // Is it an inner class?
    final AbstractJClass aOuter = aRealReference.outer ();

    f.print ("((").generable (_type).print (')').generable (_object).print (')');
  }

  @Override
  public boolean equals (final Object o)
  {
    if (o == this)
      return true;
    if (o == null || getClass () != o.getClass ())
      return false;
    final JCast rhs = (JCast) o;

  public JBreak (@Nullable final JLabel label)
  {
    m_aLabel = label;
  }

  @Nullable
  public JLabel label ()
  {
    return m_aLabel;
  }

  public void state (@Nonnull final JFormatter f)
  {
    if (m_aLabel == null)
      f.print ("break;").newline ();

    _values.add (a);
    return a;
  }

  @Nonnull
  public <W extends IJAnnotationWriter <?>> W annotate2 (@Nonnull final Class <W> clazz)
  {
    return TypedAnnotationWriter.create (clazz, this);
  }

  /**
   * {@link IJAnnotatable#annotations()}
   *
   * @see #getAllAnnotations()
   */
  @SuppressWarnings ({ "unchecked", "rawtypes" })

  }

  //
  // Equality is based on value
  //

  @Override
  public boolean equals (final Object obj)
  {
    if (obj == this)
      return true;
    if (obj == null || !getClass ().equals (obj.getClass ()))
      return false;

    final JArrayClass rhs = (JArrayClass) obj;

    f.type (m_aType).print ('.').print (m_sName);
  }

  @Override
  public boolean equals (final Object o)
  {
    if (o == this)
      return true;
    if (o == null || getClass () != o.getClass ())
      return false;
    final JEnumConstant rhs = (JEnumConstant) o;

    buf.append (_basis.fullName ());
    buf.append ('<');
    boolean first = true;
    for (final AbstractJClass c : _args)
    {
      if (first)
        first = false;
      else
        buf.append (',');
      buf.append (c.fullName ());

  public static void isArrayOfsLen (@Nonnull final Object [] aArray,
                                    @Nonnegative final int nOfs,
                                    @Nonnegative final int nLen)
  {
    notNull (aArray, "Array");
    _isArrayOfsLen (aArray.length, nOfs, nLen);
  }

  public static void isArrayOfsLen (@Nonnull final boolean [] aArray,

      f.print ('}');
  }

  @Override
  public boolean equals (final Object o)
  {
    if (o == this)
      return true;
    if (o == null || getClass () != o.getClass ())
      return false;
    final JArray rhs = (JArray) o;

  public void write (@Nonnull final String buf, @Nonnegative final int off, @Nonnegative final int len) throws IOException
  {
    write (buf.toCharArray (), off, len);
  }

  @Override
  public void write (@Nonnull final String buf) throws IOException

  }

  @Nonnull
  public JBlock body ()
  {
    if (m_aBody == null)
      m_aBody = new JBlock ();
    return m_aBody;
  }

  public void state (@Nonnull final JFormatter f)
  {
    f.print ("do");

                                          final short nUpperBoundInclusive)
  {
    if (nValue < nLowerBoundInclusive || nValue > nUpperBoundInclusive)
      throw new IllegalArgumentException ("The value of '" +
                                          sName +
                                          "' must be >= " +
                                          nLowerBoundInclusive +
                                          " and <= " +
                                          nUpperBoundInclusive +
                                          "! The current value is: " +
                                          nValue);
    return nValue;
  }

  /**
   * Check if
   * <code>nValue &ge; nLowerBoundInclusive &amp;&amp; nValue &le; nUpperBoundInclusive</code>
   *
   * @param nValue
   *        Value
   * @param sName
   *        Name
   * @param nLowerBoundInclusive
   *        Lower bound
   * @param nUpperBoundInclusive
   *        Upper bound
   * @return The value
   */
  public static int isBetweenInclusive (final int nValue,

  }

  @Nonnull
  public <W extends IJAnnotationWriter <?>> W annotate2 (@Nonnull final Class <W> clazz)
  {
    return TypedAnnotationWriter.create (clazz, this);
  }

  /**
   * {@link IJAnnotatable#annotations()}
   *
   * @see #getAllAnnotations()
   */
  @SuppressWarnings ({ "unchecked", "rawtypes" })

    if (m_aAnnotations == null)
      m_aAnnotations = new ArrayList <JAnnotationUse> ();
    final JAnnotationUse a = new JAnnotationUse (clazz);
    m_aAnnotations.add (a);
    return a;
  }

  @Nonnull
  public <W extends IJAnnotationWriter <?>> W annotate2 (@Nonnull final Class <W> clazz)

    return Collections.<AbstractJClass> emptyList ().iterator ();
  }

  @Override
  public boolean isInterface ()
  {
    return false;
  }

  @Override
  public boolean isAbstract ()
  {
    return false;
  }

  @Override
  @Nonnull
  protected AbstractJClass substituteParams (final JTypeVar [] variables, final List <? extends AbstractJClass> bindings)

  public static <T extends Iterable <?>> T notEmptyNoNullValue (final T aValue, final String sName)
  {
    notEmpty (aValue, sName);
    noNullValue (aValue, sName);
    return aValue;
  }

  /**
   * Check that the passed map is neither <code>null</code> nor empty and that
   * no <code>null</code> value is contained.
   *
   * @param <T>
   *        Type to be checked and returned
   * @param aValue
   *        The map to check.
   * @param sName
   *        The name of the value (e.g. the parameter name)
   * @return The passed value and never <code>null</code>.
   * @throws IllegalArgumentException
   *         if the passed value is empty or a <code>null</code> value is
   *         contained
   */
  @Nonnull
  public static <T extends Map <?, ?>> T notEmptyNoNullValue (final T aValue, final String sName)

  }

  @Nonnull
  public List <JTypeVar> typeParamList ()
  {
    if (_typeVariables == null)
      return Collections.<JTypeVar> emptyList ();
    return new ArrayList <JTypeVar> (_typeVariables.values ());

  }

  @Nonnull
  public JBlock body ()
  {
    if (m_aBody == null)
      m_aBody = new JBlock ();
    return m_aBody;
  }

  public void state (@Nonnull final JFormatter f)
  {

  public JAnnotationUse paramArray (@Nonnull final String name, @Nonnull final Enum <?>... values)
  {
    paramArray (name).params (values);
    return this;
  }

  /**
   * Adds a member value pair to this annotation
   *
   * @param name
   *        The simple name for this annotation
   * @param value
   *        The {@link JEnumConstant} which is member value for this annotation
   * @return The {@link JAnnotationUse}. More member value pairs can be added to
   *         it using the same or the overloaded methods.
   */
  @Nonnull
  public JAnnotationUse param (@Nonnull final String name, @Nonnull final JEnumConstant value)

    final JPackage [] pkgs = _packages.values ().toArray (new JPackage [_packages.size ()]);
    // avoid concurrent modification exception
    for (final JPackage pkg : pkgs)

  }

  @Override
  @Nonnull
  public Iterator <AbstractJClass> _implements ()
  {
    return Collections.<AbstractJClass> emptyList ().iterator ();
  }

  @Override
  public boolean isAbstract ()

  public JCHashCodeGenerator append (@Nullable final Object x)
  {
    _checkClosed ();
    m_nHC = JCHashCodeCalculator.append (m_nHC, x);
    return this;
  }

  /**
   * Object hash code generation.
   *
   * @param x
   *        Array to add
   * @return this
   */
  @Nonnull
  public JCHashCodeGenerator append (@Nullable final Enum <?> x)

  public JCHashCodeGenerator append (@Nullable final Enum <?> x)
  {
    _checkClosed ();
    m_nHC = JCHashCodeCalculator.append (m_nHC, x);
    return this;
  }

  /**
   * Array hash code generation.
   *
   * @param x
   *        Array to add
   * @return this
   */
  @Nonnull
  public JCHashCodeGenerator append (@Nullable final boolean [] x)

  public JCHashCodeGenerator append (@Nullable final boolean [] x)
  {
    _checkClosed ();
    m_nHC = JCHashCodeCalculator.append (m_nHC, x);
    return this;
  }

  /**
   * Array hash code generation.
   *
   * @param x
   *        Array to add
   * @return this
   */
  @Nonnull
  public JCHashCodeGenerator append (@Nullable final byte [] x)

  public static short isGT0 (final short nValue, final String sName)
  {
    if (nValue <= 0)
      throw new IllegalArgumentException ("The value of '" + sName + "' must be > 0! The current value is: " + nValue);
    return nValue;
  }

  public static int isGT0 (final int nValue, final String sName)

  public static short isLT0 (final short nValue, final String sName)
  {
    if (nValue >= 0)
      throw new IllegalArgumentException ("The value of '" + sName + "' must be < 0! The current value is: " + nValue);
    return nValue;
  }

  public static int isLT0 (final int nValue, final String sName)

    return new FilterOutputStream (m_aPS)
    {
      @Override
      public void close ()
      {
        // don't let this stream close
      }
    };
  }

  @Override
  public void close () throws IOException
  {
    m_aPS.close ();