Collects all the bean meta data information from the input BeanMetaData, EnterpriseBan
and dtdVersion objects, converts them to their textual representation and write it out
to the trace.log.
963216
public static void writeTraceBeanMetaData(BeanMetaData bmd,
                                              int dtdVersion)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
        {
            StringBuffer sbuf = new StringBuffer();

            sbuf
                            .append(BMD_Type_Str).append(DataDelimiter)
                            .append(BMD_Type).append(DataDelimiter)
                            .append(dtdVersion).append(DataDelimiter)
                            .append(bmd.j2eeName).append(DataDelimiter)
                            .append(bmd.simpleJndiBindingName).append(DataDelimiter);

            if (bmd.type == InternalConstants.TYPE_STATELESS_SESSION) {

                sbuf
                                .append("Stateless")
                                .append(" Session Bean").append(DataDelimiter);
                if (bmd.usesBeanManagedTx) {
                    sbuf.append("BMT").append(DataDelimiter);
                } else {
                    sbuf.append("CMT").append(DataDelimiter);
                }
                sbuf.append("N/A").append(DataDelimiter); // dxxxxxx

            } else if (bmd.type == InternalConstants.TYPE_STATEFUL_SESSION) {

                sbuf
                                .append("Stateful")
                                .append(" Session Bean").append(DataDelimiter);
                if (bmd.usesBeanManagedTx) {
                    sbuf.append("BMT").append(DataDelimiter);
                } else {
                    sbuf.append("CMT").append(DataDelimiter);
                }
                sbuf.append("N/A").append(DataDelimiter);

            } else if (bmd.type == InternalConstants.TYPE_SINGLETON_SESSION) { //F743-508.CodRev

                sbuf
                                .append("Singleton")
                                .append(" Session Bean").append(DataDelimiter);
                if (bmd.usesBeanManagedTx) {
                    sbuf.append("BMT").append(DataDelimiter);
                } else {
                    sbuf.append("CMT").append(DataDelimiter);
                }
                sbuf.append("N/A").append(DataDelimiter);

            } else if (bmd.type == InternalConstants.TYPE_BEAN_MANAGED_ENTITY) {

                sbuf
                                .append("BMP")
                                .append(" Entity Bean").append(DataDelimiter)
                                .append("CMT").append(DataDelimiter)
                                .append("N/A").append(DataDelimiter);

            } else if (bmd.type == InternalConstants.TYPE_CONTAINER_MANAGED_ENTITY) {

                sbuf
                                .append("CMP")
                                .append(" Entity Bean").append(DataDelimiter)
                                .append("CMT").append(DataDelimiter);
                int cmpV = bmd.getCMPVersion();
                sbuf.append(cmpV).append(".x").append(DataDelimiter);

            } else if (bmd.type == InternalConstants.TYPE_MESSAGE_DRIVEN) {
                sbuf.append("Message Driven Bean").append(DataDelimiter);
                if (bmd.usesBeanManagedTx) {
                    sbuf.append("BMT").append(DataDelimiter);
                } else {
                    sbuf.append("CMT").append(DataDelimiter);
                }
                sbuf.append("N/A").append(DataDelimiter);
            }

            sbuf
                            .append(turnNullClass2EmptyString(bmd.homeInterfaceClass)).append(DataDelimiter)
                            .append(turnNullClass2EmptyString(bmd.remoteInterfaceClass)).append(DataDelimiter)
                            .append(turnNullClass2EmptyString(bmd.remoteImplClass)).append(DataDelimiter)
                            .append(turnNullClass2EmptyString(bmd.homeRemoteImplClass)).append(DataDelimiter)

                            .append(turnNullClass2EmptyString(bmd.localHomeInterfaceClass)).append(DataDelimiter)
                            .append(turnNullClass2EmptyString(bmd.localInterfaceClass)).append(DataDelimiter)
                            .append(turnNullClass2EmptyString(bmd.localImplClass)).append(DataDelimiter)
                            .append(turnNullClass2EmptyString(bmd.homeLocalImplClass)).append(DataDelimiter);

            sbuf
                            .append(turnNullClass2EmptyString(bmd.homeBeanClass)).append(DataDelimiter)
                            .append(turnNullClass2EmptyString(bmd.enterpriseBeanClass)).append(DataDelimiter)
                            .append(turnNullClass2EmptyString(bmd.enterpriseBeanAbstractClass)).append(DataDelimiter)

                            .append(turnNullClass2EmptyString(bmd.pKeyClass)).append(DataDelimiter)

                            .append(bmd.minPoolSize).append(DataDelimiter)
                            .append(bmd.maxPoolSize).append(DataDelimiter)
                            .append(bmd.reentrant).append(DataDelimiter)
                            .append(bmd.sessionTimeout).append(DataDelimiter)
                            .append(bmd.isPreFindFlushEnabled).append(DataDelimiter)
                            .append(bmd.optionACommitOption ? "A"
                                            : bmd.optionBCommitOption ? "B"
                                                            : bmd.optionCCommitOption ? "C"
                                                                            : "Unknown").append(DataDelimiter);

            writeMethodInfo(sbuf, bmd.methodInfos);
            writeMethodInfo(sbuf, bmd.localMethodInfos);
            writeMethodInfo(sbuf, bmd.homeMethodInfos);
            writeMethodInfo(sbuf, bmd.localHomeMethodInfos);

            ResourceRefConfigList resRefList = bmd._resourceRefList;
            int resourcesDefined = resRefList.size();
            sbuf.append(resourcesDefined).append(DataDelimiter);
            for (int i = 0; i < resourcesDefined; ++i)
            {
                ResourceRefConfig resRef = resRefList.getResourceRefConfig(i);
                sbuf
                                .append(turnNullString2EmptyString(resRef.getName())).append(DataDelimiter)
                                .append(turnNullString2EmptyString(resRef.getDescription())).append(DataDelimiter)
                                .append(turnNullString2EmptyString(resRef.getJNDIName())).append(DataDelimiter)
                                .append(turnNullString2EmptyString(resRef.getType())).append(DataDelimiter)
                                .append(resRef.getIsolationLevel()).append(DataDelimiter)
                                .append(resRef.getSharingScope()).append(DataDelimiter)
                                .append(resRef.getAuth()).append(DataDelimiter);
            }
            // d214462 Begins
            // EJB 2.1 - TimedObject           d174057.3
            sbuf.append((dtdVersion >= BeanMetaData.J2EE_EJB_VERSION_2_1 && bmd.isTimedObject)).append(DataDelimiter);

            // MDB 2.0/2.1 and greater ActivationSpec/MessageDestination    LI2110-46
            sbuf
                            .append(turnNullString2EmptyString(bmd.ivActivationSpecJndiName)).append(DataDelimiter)
                            .append(turnNullString2EmptyString(bmd.ivMessageDestinationJndiName)).append(DataDelimiter);

            writeMethodInfo(sbuf, bmd.timedMethodInfos);
            writeMethodInfo(sbuf, bmd.wsEndpointMethodInfos);

            // EJB 2.1 - WebService Endpoint Interface / Wrapper       d174057.3
            sbuf.append(turnNullClass2EmptyString(bmd.webserviceEndpointInterfaceClass)).append(DataDelimiter);

            /**** N O T E S ****/
            // All new metadata MUST append to the sbuf to maintain backward compatibility

            //          sbuf.append( turnNullClass2EmptyString( bmd.webserviceWrapperClass ) ).append( DataDelimiter )

            // d214462 Ends
            Tr.debug(tc, sbuf.toString());
        }
    }
1109265
public Metadata parse(Element element, ParserContext context) throws Exception {
        MutableBeanMetadata beanMetadata = context.createMetadata(MutableBeanMetadata.class);
        beanMetadata.setRuntimeClass(getRuntimeClass());
        beanMetadata.setActivation(BeanMetadata.ACTIVATION_EAGER);
        beanMetadata.setScope(BeanMetadata.SCOPE_SINGLETON);
        beanMetadata.setId(getId(element));
        beanMetadata.setInitMethod("start");
        beanMetadata.setDestroyMethod("stop");
        beanMetadata.addProperty("bundleContext", createRef(context, "blueprintBundleContext"));
        extractRemainingMetaData(element, context, beanMetadata);
        return beanMetadata;
    }
767540
public static String serializeMetaData(Map<String, List<String>> metaData) {
        StringBuilder buf = new StringBuilder();
        if (metaData != null && metaData.size() > 0) {
            buf.append("<metadata xmlns=\"http://jivesoftware.com/protocol/workgroup\">");
            for (String key : metaData.keySet()) {
                List<String> value = metaData.get(key);
                for (String v : value) {
                    buf.append("<value name=\"").append(key).append("\">");
                    buf.append(StringUtils.escapeForXmlText(v));
                    buf.append("</value>");
                }
            }
            buf.append("</metadata>");
        }
        return buf.toString();
    }
429146
public static StatsTraceContext newServerContext(
      List<? extends ServerStreamTracer.Factory> factories,
      String fullMethodName,
      Metadata headers) {
    if (factories.isEmpty()) {
      return NOOP;
    }
    StreamTracer[] tracers = new StreamTracer[factories.size()];
    for (int i = 0; i < tracers.length; i++) {
      tracers[i] = factories.get(i).newServerStreamTracer(fullMethodName, headers);
    }
    return new StatsTraceContext(tracers);
  }
840506
protected BeanMetaData getBeanMetaData() {

        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && tc.isEntryEnabled())
            Tr.entry(tc, "getBeanMetaData: " + this);

        EJSHome home;

        try {
            // Get the currently installed and active home for this timer. It
            // is possible the home is not currently running, so an
            // EJBNotFoundException may occur.
            home = EJSContainer.getDefaultContainer().getInstalledHome(j2eeName);

            // Verify that the bean is still a Timer bean, in case the
            // application has been modified since the timer was created.
            if ((home.beanMetaData.timedMethodInfos) == null) {
                Tr.warning(tc, "HOME_NOT_FOUND_CNTR0092W", j2eeName);
                throw new EJBNotFoundException("Incompatible Application Change: " + j2eeName + " no longer supports timers.");
            }
        } catch (EJBNotFoundException ejbnfex) {
            FFDCFilter.processException(ejbnfex, CLASS_NAME + ".getBeanMetaData", "635", this);
            if (isTraceOn && tc.isEntryEnabled())
                Tr.exit(tc, "getBeanMetaData: Failed locating timer bean " + j2eeName + " : " + ejbnfex);
            throw new TimerServiceException("Failed locating timer bean " + j2eeName, ejbnfex);
        }

        BeanMetaData bmd = home.beanMetaData;

        if (isTraceOn && tc.isEntryEnabled())
            Tr.exit(tc, "getBeanMetaData: " + bmd);

        return bmd;
    }
849584
private void readMetadata() throws SQLException {
    if (valid) {
      return;
    }

    String[] metaInfos = queryMetaInfos(isFunction);
    String paramList = metaInfos[0];
    String functionReturn = metaInfos[1];

    parseParamList(isFunction, paramList);

    // parse type of the return value (for functions)
    if (isFunction) {
      parseFunctionReturnParam(functionReturn);
    }

  }
415680
private KeyedBackendSerializationProxy<K> readMetaData(StreamStateHandle metaStateHandle) throws Exception {

		FSDataInputStream inputStream = null;

		try {
			inputStream = metaStateHandle.openInputStream();
			cancelStreamRegistry.registerCloseable(inputStream);
			DataInputView in = new DataInputViewStreamWrapper(inputStream);
			return readMetaData(in);
		} finally {
			if (cancelStreamRegistry.unregisterCloseable(inputStream)) {
				inputStream.close();
			}
		}
	}
954577
function processMetadata () {
				//only interprete the metadata if the analytics model was not initialised yet
				if (that.bIsInitialized) {
					return;
				}

				//mark analytics model as initialized
				that.bIsInitialized = true;

				/*
				 * add extra annotations if provided
				 */
				if (mParameter && mParameter.sAnnotationJSONDoc) {
					that.mergeV2Annotations(mParameter.sAnnotationJSONDoc);
				}

				that._interpreteMetadata(that._oModel.getServiceMetadata().dataServices);
			}
506806
static void debugLogMetadata(IIOMetadata metadata, String format)
    {
        if (!logger.isDebugEnabled())
        {
            return;
        }

        // see http://docs.oracle.com/javase/7/docs/api/javax/imageio/
        //     metadata/doc-files/standard_metadata.html
        IIOMetadataNode root = (IIOMetadataNode) metadata.getAsTree(format);
        try
        {
            StringWriter xmlStringWriter = new StringWriter();
            StreamResult streamResult = new StreamResult(xmlStringWriter);
            Transformer transformer = TransformerFactory.newInstance().newTransformer();
            // see http://stackoverflow.com/a/1264872/535646
            transformer.setOutputProperty(OutputKeys.INDENT, "yes");
            transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
            DOMSource domSource = new DOMSource(root);
            transformer.transform(domSource, streamResult);
            logger.debug("\n" + xmlStringWriter);
        }
        catch (Exception e)
        {
            logger.error("Error while reporting meta-data", e);
        }
    }
1142967
public static final void getAnnotationCMTransactions(TransactionAttribute[] tranAttrs,
                                                         int methodInterfaceType,
                                                         Method[] beanMethods,
                                                         BeanMetaData bmd)
    {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && tc.isEntryEnabled())
            Tr.entry(tc, "getAnnotationCMTransactions");

        for (int i = 0; i < beanMethods.length; i++)
        {
            // Only get the value from annotations if it is not already set by WCCM
            if (tranAttrs[i] == null)
            {
                javax.ejb.TransactionAttribute methTranAttr = null;

                // Don't bother looking for annotations, if we're told there are none.
                if (!bmd.metadataComplete) {
                    methTranAttr = beanMethods[i].getAnnotation(javax.ejb.TransactionAttribute.class);

                    if (methTranAttr == null &&
                        // EJB 3.2, section 4.3.14:
                        // "A stateful session bean's PostConstruct, PreDestroy,
                        // PrePassivate or PostActivate lifecycle callback
                        // interceptor method is invoked in the scope of a
                        // transaction determined by the transaction attribute
                        // specified in the lifecycle callback method's metadata
                        // annotations or deployment descriptor"
                        (bmd.type != InternalConstants.TYPE_STATEFUL_SESSION ||
                        methodInterfaceType != InternalConstants.METHOD_INTF_LIFECYCLE_INTERCEPTOR))
                    {
                        methTranAttr = beanMethods[i].getDeclaringClass().getAnnotation(javax.ejb.TransactionAttribute.class);

                        if (isTraceOn && tc.isDebugEnabled() &&
                            methTranAttr != null)
                            Tr.debug(tc, beanMethods[i].getName() + " from class " +
                                         beanMethods[i].getDeclaringClass().getName());
                    }
                }

                if (methTranAttr == null) {
                    // set the default value
                    if (methodInterfaceType == InternalConstants.METHOD_INTF_LIFECYCLE_INTERCEPTOR &&
                        bmd.type == InternalConstants.TYPE_STATEFUL_SESSION) {
                        // "By default a stateful session bean's PostConstruct,
                        // PreDestroy, PrePassivate and PostActivate methods are
                        // executed in an unspecified transactional context."
                        //
                        // WebSphere implements an unspecified transactional
                        // context as TX_NOT_SUPPORTED.
                        tranAttrs[i] = TransactionAttribute.TX_NOT_SUPPORTED;
                    } else {
                        tranAttrs[i] = TransactionAttribute.TX_REQUIRED;
                    }

                    if (isTraceOn && tc.isDebugEnabled())
                        Tr.debug(tc, beanMethods[i].getName() + " = REQUIRED (defaulted)");
                } else {
                    // Switch the javax.ejb.TransactionAttribute to com.ibm.websphere.csi.TransactionAttribute
                    int tranType = methTranAttr.value().ordinal();
                    tranAttrs[i] = txAttrFromJEE15Map[tranType];

                    if (isTraceOn && tc.isDebugEnabled())
                        Tr.debug(tc, beanMethods[i].getName() + " = " + methTranAttr.value());
                }
            }
        }

        if (isTraceOn && tc.isEntryEnabled()) {
            Tr.exit(tc, "getAnnotationsCMTransactions", Arrays.toString(tranAttrs));
        }

    }
1210394
private void generateContextHandlerMeta(final Set<Bean<?>> processBeans) {
        for (final Bean<?> latkeBean : processBeans) {
            final Class<?> clz = latkeBean.getBeanClass();
            final Method[] declaredMethods = clz.getDeclaredMethods();
            for (int i = 0; i < declaredMethods.length; i++) {
                final Method method = declaredMethods[i];
                final RequestProcessing requestProcessingMethodAnn = method.getAnnotation(RequestProcessing.class);
                if (null == requestProcessingMethodAnn) {
                    continue;
                }

                final ContextHandlerMeta contextHandlerMeta = new ContextHandlerMeta();
                contextHandlerMeta.setUriTemplates(requestProcessingMethodAnn.value());
                contextHandlerMeta.setHttpMethods(requestProcessingMethodAnn.method());
                contextHandlerMeta.setInvokeHolder(method);
                contextHandlerMeta.initProcessAdvices();

                addContextHandlerMeta(contextHandlerMeta);
            }
        }
    }
538289
@SuppressWarnings("null")
    private Object parseBean(final Class<?> beanType) throws Exception {
        String propName = "";
        try {
            XMLEvent event = null;
            // handle case where whole bean is Joda-Convert string
            if (settings.getConverter().isConvertible(beanType)) {
                StringBuilder buf = new StringBuilder();
                while (reader.hasNext()) {
                    event = nextEvent(">btxt ");
                    if (event.isCharacters()) {
                        buf.append(event.asCharacters().getData());
                    } else if (event.isEndElement()) {
                        return settings.getConverter().convertFromString(beanType, buf.toString());
                    } else if (event.isStartElement()) {
                        break;  // not serialized via Joda-Convert
                    } else if (event.isEndDocument()) {
                        throw new IllegalArgumentException("Unexpected end of document");
                    }
                }
            } else {
                event = nextEvent(">bean ");
            }
            // handle structured bean
            SerDeserializer deser = settings.getDeserializers().findDeserializer(beanType);
            MetaBean metaBean = deser.findMetaBean(beanType);
            BeanBuilder<?> builder = deser.createBuilder(beanType, metaBean);
            // handle beans with structure
            while (event.isEndElement() == false) {
                if (event.isStartElement()) {
                    StartElement start = event.asStartElement();
                    propName = start.getName().getLocalPart();
                    MetaProperty<?> metaProp = deser.findMetaProperty(beanType, metaBean, propName);
                    if (metaProp == null || metaProp.style().isDerived()) {
                        int depth = 0;
                        event = nextEvent(" skip ");
                        while (event.isEndElement() == false || depth > 0) {
                            if (event.isStartElement()) {
                                depth++;
                            } else if (event.isEndElement()) {
                                depth--;
                            }
                            event = nextEvent(" skip ");
                        }
                        // skip elements
                    } else {
                        Class<?> childType = parseTypeAttribute(start, SerOptional.extractType(metaProp, beanType));
                        Object value;
                        if (Bean.class.isAssignableFrom(childType)) {
                            value = parseBean(childType);
                        } else {
                            SerIterable iterable = settings.getIteratorFactory().createIterable(metaProp, beanType);
                            if (iterable != null) {
                                value = parseIterable(start, iterable);
                            } else {
                                // metatype
                                Attribute metaTypeAttr = start.getAttributeByName(METATYPE_QNAME);
                                if (metaTypeAttr != null) {
                                    iterable = settings.getIteratorFactory().createIterable(metaTypeAttr.getValue(), settings, knownTypes);
                                    if (iterable == null) {
                                        throw new IllegalArgumentException("Invalid metaType");
                                    }
                                    value = parseIterable(start, iterable);
                                } else {
                                    String text = advanceAndParseText();
                                    value = settings.getConverter().convertFromString(childType, text);
                                }
                            }
                        }
                        deser.setValue(builder, metaProp, SerOptional.wrapValue(metaProp, beanType, value));
                    }
                    propName = "";
                }
                event = nextEvent(".bean ");
            }
            return deser.build(beanType, builder);
        } catch (Exception ex) {
            throw new RuntimeException("Error parsing bean: " + beanType.getName() + "::" + propName + ", " + ex.getMessage(), ex);
        }
    }
1079420
public void printMetadata() throws Exception {

        log.info("-----------------");
        log.info("RAFT Log Metadata");
        log.info("-----------------");

        byte[] firstAppendedBytes = db.get(FIRSTAPPENDED);
        log.info("First Appended: %d", fromByteArrayToInt(firstAppendedBytes));
        byte[] lastAppendedBytes = db.get(LASTAPPENDED);
        log.info("Last Appended: %d", fromByteArrayToInt(lastAppendedBytes));
        byte[] currentTermBytes = db.get(CURRENTTERM);
        log.info("Current Term: %d", fromByteArrayToInt(currentTermBytes));
        byte[] commitIndexBytes = db.get(COMMITINDEX);
        log.info("Commit Index: %d", fromByteArrayToInt(commitIndexBytes));
        Address votedForTmp =Util.objectFromByteBuffer(db.get(VOTEDFOR));
        log.info("Voted for: %s", votedForTmp);
    }
1142111
protected void generateMetadata(IXmlStyleAppendable it) {
		it.appendTagWithValue("property", //$NON-NLS-1$
				Strings.concat(";", getMimeTypes()), //$NON-NLS-1$
				"name", "mimetypes"); //$NON-NLS-1$ //$NON-NLS-2$

		final StringBuilder buffer = new StringBuilder();
		for (final String fileExtension : getLanguage().getFileExtensions()) {
			if (buffer.length() > 0) {
				buffer.append(";"); //$NON-NLS-1$
			}
			buffer.append("*.").append(fileExtension); //$NON-NLS-1$
		}
		it.appendTagWithValue("property", //$NON-NLS-1$
				buffer.toString(),
				"name", "globs"); //$NON-NLS-1$ //$NON-NLS-2$

		it.appendTagWithValue("property", //$NON-NLS-1$
				"//", //$NON-NLS-1$
				"name", "line-comment-start"); //$NON-NLS-1$ //$NON-NLS-2$

		it.appendTagWithValue("property", //$NON-NLS-1$
				"/*", //$NON-NLS-1$
				"name", "block-comment-start"); //$NON-NLS-1$ //$NON-NLS-2$

		it.appendTagWithValue("property", //$NON-NLS-1$
				"*/", //$NON-NLS-1$
				"name", "block-comment-end"); //$NON-NLS-1$ //$NON-NLS-2$
	}
633045
@SuppressWarnings("unchecked")
    protected static void logMetaInf()
    {
        if (!log.isLoggable(Level.WARNING))
        {
          return;
        }

        try
        {
            Map<String, List<JarInfo>> libs = new HashMap<String, List<JarInfo>>(30);

            Iterator<URL> it = ClassUtils.getResources("META-INF/MANIFEST.MF", LogMetaInfUtils.class);
            while (it.hasNext())
            {
                URL url = it.next();
                addJarInfo(libs, url);
            }

            final List<String> keys = new ArrayList(libs.keySet());
            Collections.sort(keys);

            if (log.isLoggable(Level.WARNING))
            {
                for (String artifactId : keys)
                {
                    List<JarInfo> versions = libs.get(artifactId);
                    if (versions != null && versions.size() > 1)
                    {
                        StringBuilder builder = new StringBuilder(1024);
                        builder.append("You are using the library: ");
                        builder.append(artifactId);
                        builder.append(" in different versions; first (and probably used) version is: ");
                        builder.append(versions.get(0).getVersion());
                        builder.append(" loaded from: ");
                        builder.append(versions.get(0).getUrl());
                        builder.append(", but also found the following versions: ");

                        boolean needComma = false;
                        for (int i = 1; i < versions.size(); i++)
                        {
                            JarInfo info = versions.get(i);
                            if (needComma)
                            {
                                builder.append(", ");
                            }

                            builder.append(info.getVersion());
                            builder.append(" loaded from: ");
                            builder.append(info.getUrl());

                            needComma = true;
                        }

                        log.warning(builder.toString());
                    }
                }
            }

            if (log.isLoggable(Level.INFO))
            {
                for (String artifactId : keys)
                {
                    logArtifact(artifactId, libs);
                }
            }
        }
        catch (Throwable e)
        {
            throw new FacesException(e);
        }
    }
151108
private String getBeanMethodName(String fieldName, int type) {
      if (fieldName == null || fieldName == "") { return ""; }
      String methodName = "";
      if (type == 0) {
         methodName = "get";
      } else {
         methodName = "set";
      }
      methodName += fieldName.substring(0, 1).toUpperCase();
      if (fieldName.length() == 1) { return methodName; }
      methodName += fieldName.substring(1);
      //Log.d(TAG, "fieldName: " + fieldName + " beanMethod: " + methodName);
      return methodName;
   }
484120
private ResultSetMetaData getMetaData() {

        if (metadata == null) {
            try {
                metadata = resultSet.getMetaData();
            } catch (SQLException e) {
                throw new FacesException(e);
            }
        }
        return (metadata);

    }