<html>
<head>
<title>Status File for Jakarta Commons "BeanUtils" Component</title>
<head>
<body bgcolor="white">


<div align="center">
<h1>The Jakarta Commons <em>BeanUtils</em> Component</h1>
$Id: STATUS.html,v 1.7 2002/08/13 17:11:19 sanders Exp $<br>
<a href="#Introduction">[Introduction]</a>
<a href="#Dependencies">[Dependencies]</a>
<a href="#Release Info">[Release Info]</a>
<a href="#Committers">[Committers]</a>
<a href="#Action Items">[Action Items]</a>
<br><br>
</div>


<a name="Introduction"></a>
<h3>1.  INTRODUCTION</h3>

<p>The <em>BeanUtils</em> Component contains a set of Java classes that provide
static utility methods useful in manipulating Java classes that conform to the
JavaBeans Specification naming patterns for bean properties in a dynamic
fashion.  The following classes are included:</p>
<ul>
<li><strong>BeanUtils</strong> - Higher level getters and setters that deal
    with automatic conversion of String-represented property values to the
    corresponding data types of the underlying property setters (and vice
    versa), using the capabilities of the ConvertUtils and PropertyUtils
    classes.</li>
<li><strong>ConvertUtils</strong> - Utility methods to convert String arguments
    to native Java types (and vice versa)</li>.
<li><strong>PropertyUtils</strong> - Low level getters and setters for bean
    properties that perform no type conversions at all.  Works on
    <code>List</code> objects as well (Not JavaBeans standard).</li>
</ul>

<p>An innovative and unique feature of this component is the syntax for
accessing nested and indexed bean properties.  See the Javadocs
<a href="http://jakarta.apache.org/commons/beanutils/api/">PropertyUtils</a>
for more information about this feature.</p>


<a name="Dependencies"></a>
<h3>2.  DEPENDENCIES</h3>

<p>The <em>BeanUtils</em> component is dependent upon the following external
components for development and use:</p>
<ul>
<li><a href="http://java.sun.com/j2se">Java Development Kit</a>
    (Version 1.2 or later)</li>
<li><a href="http://jakarta.apache.org/commons">Collections Classes</a>
    from the Jakarta Commons Subproject</li>
<li><a href="http://jakarta.apache.org/commons">Logging Classes</a>
    from the Jakarta Commons Subproject</li>
<li><a href="http://www.junit.org">JUnit Testing Framework</a>
    (Version 3.7 or later) - for unit tests only, not required
    for deployment</li>
</ul>


<a name="Release Info"></a>
<h3>3.  RELEASE INFO</h3>

<p>Current Release:
<a href="http://jakarta.apache.org/builds/jakarta-commons/release/commons-beanutils/v1.4/">Version 1.4</a></p>

<p>Planned Next Release:  Real Soon Now :)  See the
<a href="#Action Items">Action Items</a> list for tasks that need to be
completed prior to this release.</p>


<a name="Committers"></a>
<h3>4.  COMMITTERS</h3>

<p>The following individuals are the primary developers and maintainers of this
component.  Developers who plan to use <em>BeanUtils</em> in their own
projects are encouraged to collaborate on the future development of this
component to ensure that it continues to meet a variety of needs.</p>
<ul>
<li><a href="mailto:craigmcc@apache.org">Craig McClanahan</a>
<li><a href="mailto:geirm@apache.org">Geir Magnusson Jr.</a>
<li><a href="mailto:sanders@apache.org">Scott Sanders</a>
</ul>


<a name="Action Items"></a>
<h3>5.  ACTION ITEMS</h3>

<p>The following action items need to be completed prior to a Version 1.3
release of this component:</p>

<table border="1">

  <tr>
    <th width="80%">Action Item</th>
    <th width="20%">Volunteer</th>
  </tr>

  <tr>
    <td><strong>Solidify DynaBeans</strong>.  Finish discussions on DynaBean
         structure so that future API changes will be minimal.
    <td align="center">Craig (we hope)</td>
  </tr>

  <tr>
    <td><strong>Install / Use Documentation</strong>.  Create simple
        installation and User's Guide documentation for this component.</td>
    <td align="center">Craig</td>
  </tr>

</table>

</body>
</html>
