dot_files/vim-plugins/temp-unloaded-plugins/eclim/doc/vim/java/methods.txt

*vim-java-methods.html*

Method Generation
*****************

*:JavaConstructor*


Constructors
============

:JavaConstructor is a command that will create either an empty
constructor, or one that takes any selected fields as arguments.

For example if you have the following class:

>

   public class Foo
   {
     private int id;
     private String name;
   }

<


If you were to select the range containing the 'id' and 'name' fields
and issue :JavaConstructor, then you would end up with the following
code.

>

   public class Foo
   {
     private int id;
     private String name;

     /**
      * @param id
      * @param name
      */
     public Foo(int id, String name) {
       this.id = id;
       this.name = name;
     }
   }

<


If you issue the command with no fields selected, then a default empty
constructor is created.

When attempting to create an empty constructor, if the super class
doesn't define a default constructor, but instead has one or more
constructors which takes arguments, then calling :JavaConstructor
without a range will result in the creation of a constructor which
overrides the super class constructor containing the least number of
arguments. Although an empty constructor won't pass code validation,
you can force the creation of one in this case by suffixing the
command with a '!':

>

   :JavaConstructor!

<


*:JavaGetSet*


Getters / Setters
=================

- :JavaGetSet - Generates both getters and setters for the field
  under the cursor or for all fields in the specified range.
*:JavaGet*

- :JavaGet - Generates getters for the field under the cursor or for
  all fields in the specified range.
*:JavaSet*

- :JavaSet - Generates setters for the field under the cursor or for
  all fields in the specified range.
Note: If you would like to generate the indexed getter or setter
  then you can suffix the appropriate command above with '!' and if
  the property is an array, an indexed accessor will be created.>

     :JavaGetSet!

  <


Given the following file:

>

   public class Foo
   {
     private String name;
     private Bar[] bars;
   }

<


You can place the cursor on one of the fields and execute :JavaGetSet
to generate the getters and setters for the field.  All of the above
commands support ranges as well, so you can use a visual selection or
a numbered range to generate methods for a set of fields.

*:JavaImpl*


Override / Impl
===============

Eclim provides the ability to view all the methods that the current
source file can implement or override according to what interfaces it
implements and classes it extends. From the list of methods you can
then choose which you want to implement or override, and the
appropriate method stub will be inserted into the file.

The first step in the process is to execute :JavaImpl which will open
a Vim window containing a list possible methods to implement /
override and the interface / class which defines those methods.

Here is some example content from a class that extends
java.io.InputStream:

>

   com.test.TestStream

   package java.io;
   class InputStream
     public int read()
     public int read(byte[])
     public int read(byte[], int, int)
     public long skip(long)
     public int available()
     public void close()
     public void mark(int)
     public void reset()
     public boolean markSupported ()

   package java.lang;
   class Object
     public int hashCode()
     public boolean equals(Object)
     protected Object clone()
     public String toString()
     protected void finalize()

<


From the newly opened window you can select a method to generate a
stub for by simply hitting <enter> with the cursor over the method
signature.

If you would like to generate stubs for all methods in an interface or
class, then simply hit <enter> with the cursor over the class name and
stub methods will be created for each method in that class or
interface.

This functionality supports outer, inner, and anonymous classes
classes. To view the list of methods to override for an inner or
anonymous class, simply execute :JavaImpl with the cursor somewhere in
the body of the inner or anonymous class.


Configuration
-------------

Vim Settings (vim-settings)

*g:EclimJavaImplInsertAtCursor*

- g:EclimJavaImplInsertAtCursor (Default: 0) - By default eclim will
  insert methods you've chosen after all the existing methods, but
  before any inner classes. If you enable this setting, then the
  methods will instead be inserted near where your cursor was when you
  first invoked :JavaImpl.
*:JavaDelegate*


Delegate Methods
================

Eclim supports generation of delegate methods via the :JavaDelegate
command. To utilize this functionality you must first place the cursor
on a global field (in the main source file class or within an inner
class), and then invoke the :JavaDelegate command.

In the following source, you can place the cursor anywhere starting
from the first 'p' in private, to the trailing semicolon, and then
invoke the :JavaDelegate command.

>

   private List myList;

<


Invoking this command with the cursor on some other source element
will generate the appropriate error.

Once successfully invoked, the result will be the opening of a lower
window with all the methods that may be inserted that will delegate to
the value of the field.

Here is a section of the content displayed when invoking the command
on a field of type java.util.List like the one above.

>

   com.test.TestList.myList

   package java.util;
   interface List
     public abstract int size()
     public abstract boolean isEmpty()
     public abstract boolean contains(Object)
     public abstract Object[] toArray()
     ...

<


From this newly opened window you can select a method by simply
hitting <enter> with the cursor over the method signature and a
delegate method will be created.

For example, if you hit <enter> on the size() method, then the
following code will be inserted.

>

   /**
    */
   public int size ()
   {
     return myList.size();
   }

<


If you would like to generate delegate methods for all methods in an
interface or class, then simply hit <enter> with the cursor over the
class name, and delegate methods will be created for each method in
that interface or class.

vim:ft=eclimhelp