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).base ();
    }
    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.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 (m_aBasis.fullName ());
    buf.append ('<');
    boolean bFirst = true;
    for (final AbstractJClass c : m_aArgs)
    {
      if (bFirst)
        bFirst = 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;

    for (final Element enclosedElement : element.getEnclosedElements ())
    {
      if (enclosedElement.getKind ().equals (ElementKind.INTERFACE) ||
          enclosedElement.getKind ().equals (ElementKind.CLASS))

  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

                                          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 JBlock body ()
  {
    if (m_aBody == null)
      m_aBody = new JBlock ();
    return m_aBody;
  }

  public void state (@Nonnull final JFormatter f)
  {
    f.indent ();

                                _annotationUse.param (name, actualEnumConstantValue ((VariableElement) value));
                              }
                              catch (final ClassNotFoundException ex)
                              {
                                Logger.getLogger (Annotator.class.getName ()).log (Level.WARNING,
                                                                                   "Not processing annotation argument: {0}: {1}",
                                                                                   new Object [] { name, value });

      catch (final NoSuchFieldException ex)
      {
        throw new IllegalStateException (MessageFormat.format ("Unable to load enum constant: {0}.{1}",
                                                               enumClassElement.getQualifiedName ().toString (),
                                                               variableElement.getSimpleName ().toString ()),
                                         ex);
      }

      catch (final IllegalArgumentException ex)
      {
        throw new IllegalStateException (MessageFormat.format ("Unable to load enum constant actual value: {0}.{1}",
                                                               enumClassElement.getQualifiedName ().toString (),
                                                               variableElement.getSimpleName ().toString ()),
                                         ex);
      }

      environment.put (typeVariable.name (), typeVariable);
      for (final TypeMirror type : parameter.getBounds ())
      {
        typeVariable.bound ((AbstractJClass) _modelsAdapter.toJType (type, environment));

  public String fullName ()
  {
    if (getOuter () instanceof AbstractJClassContainer <?>)
      return ((AbstractJClassContainer <?>) getOuter ()).fullName () + '.' + name ();

  }

  /**
   * 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)

  }

  @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)

  public JDefinedClass getClass (final TypeElement element) throws CodeModelBuildingException, ErrorTypeFound
  {
    final Element enclosingElement = element.getEnclosingElement ();
    if (enclosingElement instanceof PackageElement)
    {
      final PackageElement packageElement = (PackageElement) enclosingElement;

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

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

    throw new JErrorClassUsedException (m_sMessage);
  }

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

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

  @Override
  public boolean isError ()
  {
    return true;

  public static <T extends Collection <?>> T notEmpty (final T aValue, final String sName)
  {
    notNull (aValue, sName);
    if (aValue.isEmpty ())
      throw new IllegalArgumentException ("The value of the collection '" + sName + "' may not be empty!");

  public JAnnotationUse param (@Nonnull final String name, @Nonnull final Enum <?> value)
  {
    return _addValue (name, wrap (value));
  }

  @Nonnull
  public JAnnotationUse paramArray (@Nonnull final String name, @Nonnull final Enum <?>... values)

  public JAnnotationUse paramArray (@Nonnull final String name, @Nonnull final String... 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 enum class 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 Enum <?> value)

  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 ();