Coverage Report

Coverage Report - net.sf.sapjcosupport.SapJcoInterface

Classes in this File
6,458
 package net.sf.sapjcosupport;
 
 import EDU.oswego.cs.dl.util.concurrent.PooledExecutor;
 import com.sap.mw.jco.IFunctionTemplate;
 import com.sap.mw.jco.JCO;
 import org.apache.commons.beanutils.BeanUtils;
 import org.apache.log4j.Logger;
 import org.springframework.beans.factory.InitializingBean;
 import org.springframework.dao.DataRetrievalFailureException;
 import org.springframework.util.MethodInvoker;
 
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.util.*;
 
 /**
  * Abstract superclass for all SAP data access objects.
  *
  * @author Niki Driessen
  * @since Jan 18, 2006 - 3:07:41 PM
  */
 public abstract class SapJcoInterface {
     private static final Logger logger = Logger.getLogger(SapJcoInterface.class);
     private static final Logger sapJcoXmlLogger = Logger.getLogger("SapJcoXML");
     private static SimpleReflectionCache reflectionCache = new SimpleReflectionCache();
     private static Map cache;
     private static final String FUNCTIONTEMPLATE_CACHE_KEY = "_functiontemplate";
     private static final char SELECTED = 'X';
 
     static {
         cache = Collections.synchronizedMap(new HashMap());
     }
 
     protected SapDataSource dataSource;
     protected int maxParallelCalls = 5;
 
     /**
      * Sets the maximum number of parallel calls to SAP.
      *
      * @param calls maximum number of parallel SAP calls
      */
     public void setMaxParallelCalls(int calls) {
         this.maxParallelCalls = calls;
     }
 
     /**
      * Sets the SAP data source this data access object is working on.
      *
      * @param source SAP data source
      */
     public void setDataSource(SapDataSource source) {
         this.dataSource = source;
     }
 
     /**
      * This method will resolve the FunctionTemplate for the given name.
      * It will search the local cache and if not found, retrieve it from SAP
      * via the repository. It then caches that and returns it.
      * <p/>
      * This method NEVER returns null! An exception is thrown when the function can not be resolved.
      *
      * @param name the name of the function to find
      * @return the function template
      * @throws SapJcoMappingException when the requested function can not be found in the configured repositories
      */
     protected JCO.Function getFunction(String name) {
         String cacheKey = name + FUNCTIONTEMPLATE_CACHE_KEY;
         IFunctionTemplate template = (IFunctionTemplate) cache.get(cacheKey);
         if (template == null) {
             template = dataSource.getRepository().getFunctionTemplate(name);
             if (template == null) {
                 throw new SapJcoMappingException(new StringBuffer("Could not find function '").append(name).append(
                         "'").toString());
             }
             cache.put(cacheKey, template);
         }
         return template.getFunction();
     }
 
     private class AsyncRetrieveCall extends AsyncMethodCall {
         private Class persistentObject;
         private Map input;
         private Object result;
         private String profile;
 
         public AsyncRetrieveCall(Class persistentObject, Map input, String profile) {
             this.persistentObject = persistentObject;
             this.input = input;
             this.profile = profile;
         }
 
         protected void executeMethod() {
             result = retrieve(persistentObject, input, profile);
         }
 
         protected Object getMethodReturnValue() {
             return result;
         }
     }
 
     /**
      * Actually calls a BAPI.
      */
     public Object performSapCall(SapMapping sapMapping, Map input, Class persistentObject, String profile) {
         List inputListMappings = sapMapping.getInputLists();
         SapListMapping outputListMapping = sapMapping.getOutputList();
         SapListMapping fieldSelection = sapMapping.getFieldSelection();
 
         SapBapiMapping sapBapiMapping = sapMapping.getBapi();
         JCO.Function function = getFunction(sapBapiMapping.getName());
         JCO.Client connection = dataSource.getConnection();
 
         if (logger.isInfoEnabled()) {
             logger.info("Starting SAP backend call: " + sapBapiMapping.getName());
         }
 
         //map normal inported parameters
         prepareFunctionInput(sapBapiMapping, input, function);
         //handle input lists
         prepareFunctionInputList(inputListMappings, function, input);
         //handle field selections (profiles)
         handleFieldSelection(fieldSelection, function, sapBapiMapping, profile);
 
         try {
 
             long currTime = System.currentTimeMillis();
             if (sapJcoXmlLogger.isDebugEnabled()) {
                 String tempFile = System.getProperty("java.io.tmpdir") + function
                         .getName() + "_Request-" + currTime + ".xml";
                 function.writeXML(tempFile);
                 sapJcoXmlLogger.debug("BAPI function input written to location: " + tempFile);
             }
             connection.execute(function);
             if (sapJcoXmlLogger.isDebugEnabled()) {
                 String tempFile = System.getProperty("java.io.tmpdir") + function
                         .getName() + "_Response-" + currTime + ".xml";
                 function.writeXML(tempFile);
                 sapJcoXmlLogger.debug("BAPI function output written to location: " + tempFile);
             }
             try {
                 checkReturnStructure(function);
             } catch (DataRetrievalFailureException e) {
                 logger.error("The backend call returned no data.", e);
                 return null; //no data found, so nothing do do...
             }
             JCO.ParameterList output = function.getExportParameterList();
             if (output == null) {
                 output = function.getTableParameterList();
                 if (output == null) {
                     throw new DataRetrievalFailureException("No results returned");
                 }
             }
 
             if (outputListMapping != null) {    // multiple results
                 return parseOutputList(function, outputListMapping, sapBapiMapping, fieldSelection, persistentObject);
             } else {    // single result
                 //now map to persistent object
                 return parseOutput(sapBapiMapping, fieldSelection, function, persistentObject);
             }
         } catch (JCO.Exception e) {
             throw new DataRetrievalFailureException("Underlying JCO bridge threw an exception", e);
         } catch (IllegalAccessException e) {
             throw new DataRetrievalFailureException("Instantiation of new value object instance failed", e);
         } catch (InstantiationException e) {
             throw new DataRetrievalFailureException("Instantiation of new value object instance failed", e);
         } finally {
             dataSource.release(connection);
         }
     }
 
     private Object parseOutput(SapBapiMapping sapBapiMapping, SapListMapping fieldSelection, JCO.Function function,
                                Class persistentObject) throws IllegalAccessException, InstantiationException {
         Object entity = persistentObject.newInstance();
         for (int j = 0; j < sapBapiMapping.getStructures().size(); j++) {
             SapStructureMapping sapStructureMapping = (SapStructureMapping) sapBapiMapping.getStructures().get(j);
             if (sapStructureMapping.isExcluded() || (fieldSelection != null && sapStructureMapping.getName().equals(
                     fieldSelection.getName()))) {
                 // discard excluded lists and the field selection structure when processing output
                 continue;
             }
             JCO.Field field = getField(function, sapStructureMapping.getName());
             if (field == null) {
                 throw new DataRetrievalFailureException(new StringBuffer("Field ").append(sapStructureMapping.getName())
                         .append(" not found in resultset").toString());
             }
             if (sapStructureMapping.isMap()) {
                 if (!field.isTable()) {
                     throw new SapJcoMappingException(new StringBuffer("Field ").append(sapStructureMapping.getName())
                             .append(" is mapped as table but ist one").toString());
                 }
                 JCO.Table table = field.getTable();
                 if (table.getNumRows() > 0) {
                     convertMap(table, entity, sapStructureMapping, persistentObject);
                 } else {
                     if (logger.isDebugEnabled()) {
                         logger.debug("Single result table contains no rows: " + table.getName());
                     }
                 }
             } else if (sapStructureMapping.isEntity()) {
                 if (!field.isTable()) {
                     throw new SapJcoMappingException(new StringBuffer("Field ").append(sapStructureMapping.getName())
                             .append(" is mapped as table but ist one").toString());
                 }
                 JCO.Table table = field.getTable();
                 if (table.getNumRows() > 0) {
                     if (sapStructureMapping.getCollectionName() == null) {
                         throw new SapJcoMappingException(new StringBuffer("Entity mapping defined for structure ")
                                 .append(sapStructureMapping.getName()).append(
                                 " but no collection specified in parent entity").toString());
                     }
                     List collection = new ArrayList(table.getNumRows());
                     try {
                         Class entityClass = Class.forName(sapStructureMapping.getEntityClass());
                         table.firstRow();
                         do {
                             Object childEntity = instantiate(entityClass);
                             mapRecordToEntity(entityClass, childEntity, table, sapStructureMapping);
                             collection.add(childEntity);
                         } while (table.nextRow());
                         BeanUtils.setProperty(entity, sapStructureMapping.getCollectionName(), collection);
                     } catch (InvocationTargetException e) {
                         throw new SapJcoMappingException(
                                 "Error mapping entity collection " + sapStructureMapping.getCollectionName(), e);
                     } catch (ClassNotFoundException e) {
                         throw new SapJcoMappingException(
                                 "Can not find entity class " + sapStructureMapping.getEntityClass(), e);
                     }
                 } else {
                     logger.info("No rows for entity collection " + sapStructureMapping.getName());
                 }
             } else {
                 JCO.Record record;
                 if (!field.isStructure()) {
                     field.getTable().firstRow();
                     record = field.getTable();
                 } else {
                     record = field.getStructure();
                 }
                 mapRecordToEntity(persistentObject, entity, record, sapStructureMapping);
             }
         }
         if (entity != null && entity instanceof InitializingBean) {
             try {
                 ((InitializingBean) entity).afterPropertiesSet();
             } catch (Exception e) {
                 throw new DataRetrievalFailureException(
                         "Encountered problems while executing 'afterPropertiesSet' on value bean", e);
             }
         }
         return entity;
     }
 
     private List parseOutputList(JCO.Function function, SapListMapping outputListMapping,
                                  SapBapiMapping sapBapiMapping, SapListMapping fieldSelection, Class persistentObject)
             throws IllegalAccessException, InstantiationException {
         JCO.Field outputField = getField(function, outputListMapping.getName());
         JCO.Table outputList = checkAndGetTable(outputField);
         outputList.firstRow();
         List results = new ArrayList();
         do {
             Object entity = persistentObject.newInstance();
             String pkField = outputListMapping.getPrimaryKey();
             if (outputList.getNumRows() == 0) {
                 return results;
             }
             String pkValue = outputList.getString(pkField);
             if (pkValue == null) {
                 continue;
             }
             for (int j = 0; j < sapBapiMapping.getStructures().size(); j++) {
                 SapStructureMapping sapStructureMapping = (SapStructureMapping) sapBapiMapping.getStructures().get(j);
                 if (sapStructureMapping.isExcluded() || (fieldSelection != null && sapStructureMapping.getName().equals(
                         fieldSelection.getName()))) {
                     // discard excluded lists and the field selection structure when processing output
                     continue;
                 }
                 JCO.Field field = getField(function, sapStructureMapping.getName());
                 if (field == null) {
                     throw new DataRetrievalFailureException(new StringBuffer("Field ").append(
                             sapStructureMapping.getName()).append(" not found in resultset").toString());
                 }
 
                 if (sapStructureMapping.getName().equalsIgnoreCase(outputListMapping.getName())) {
                     //map the current row
                     mapRecordToEntity(persistentObject, entity, outputList, sapStructureMapping);
                 } else {
                     //handle map
                     if (sapStructureMapping.isListOfMaps()) {
                         JCO.Table table = checkAndGetTable(field);
                         if (table.getNumRows() == 0) {
                             if (logger.isDebugEnabled()) {
                                 logger.debug("Multiple result table contains no rows: " + table.getName());
                             }
                             continue; // process next row
                         }
 
                         //filter
                         JCO.Table filteredTable = filterTable(table, pkField, pkValue);
                         if (filteredTable.getNumRows() == 0) {
                             if (logger.isDebugEnabled()) {
                                 logger.debug("Filtered result table contains no rows: " + table
                                         .getName() + "; filtered on key: " + pkField + "=" + pkValue);
                             }
                         } else {
                             //map
                             convertMap(filteredTable, entity, sapStructureMapping, persistentObject);
                         }
                     } else if (sapStructureMapping.isList()) {
                         //advance pointer
                         JCO.Table record = checkAndGetTable(field);
                         record.setRow(outputList.getRow());
                         mapRecordToEntity(persistentObject, entity, record, sapStructureMapping);
                     } else {
                         throw new SapJcoMappingException(
                                 "Output list defined, structure type must be 'list' or 'list' with 'key-field' and 'pk' attribute defined");
                     }
                 }
             }
             if (entity != null && entity instanceof InitializingBean) {
                 try {
                     ((InitializingBean) entity).afterPropertiesSet();
                 } catch (Exception e) {
                     throw new DataRetrievalFailureException(
                             "Encountered problems while executing 'afterPropertiesSet' on value bean", e);
                 }
             }
             results.add(entity);
         } while (outputList.nextRow());
         return results;
     }
 
     private void handleFieldSelection(SapListMapping fieldSelection, JCO.Function function,
                                       SapBapiMapping sapBapiMapping, String profile) {
         if (fieldSelection != null) {
             JCO.Structure fieldSelectionStructure = function.getImportParameterList().getStructure(
                     fieldSelection.getName());
             Collection selectedFields = sapBapiMapping.getFieldSelection(profile);
             if (selectedFields == null) {
                 //select ALL
                 JCO.FieldIterator iterator = fieldSelectionStructure.fields();
                 while (iterator.hasNextFields()) {
                     JCO.Field field = iterator.nextField();
                     field.setValue(SELECTED);
                 }
             } else {
                 for (Iterator i = selectedFields.iterator(); i.hasNext();) {
                     Object value = i.next();
                     fieldSelectionStructure.setValue(SELECTED, String.valueOf(value));
                 }
             }
         }
     }
 
     private void prepareFunctionInputList(List inputListMappings, JCO.Function function, Map input) {
         if (inputListMappings != null) {
             JCO.ParameterList tableList = function.getTableParameterList();
             for (Iterator inputListIterator = inputListMappings.iterator(); inputListIterator.hasNext();) {
                 SapListMapping inputListMapping = (SapListMapping) inputListIterator.next();
                 JCO.Table inputTable = tableList.getTable(inputListMapping.getName());
                 if (inputTable == null) {
                     throw new SapJcoMappingException("Input table '" + inputListMapping.getName() + "' doesn't exist");
                 }
                 Collection inputValues = (Collection) input.get(inputListMapping.getName());
                 if (inputValues != null) {
                     for (Iterator valueIterator = inputValues.iterator(); valueIterator.hasNext();) {
                         Object value = valueIterator.next();
                         inputTable.appendRow();
                         if (value instanceof Map) {
                             // This approach was introduced to enable multiple fields to be set, not just the primary key field.
                             // The keys of the Map.Entry should map exactly to the SAP field names (*NOT* the name of the corresponding java fields)
                             // The use of the primary key field in the input list mapping is bypassed..
                             Map fields = (Map) value;
                             for (Iterator entrySetIterator = fields.entrySet().iterator(); entrySetIterator.hasNext();)
                             {
                                 Map.Entry entry = (Map.Entry) entrySetIterator.next();
                                 inputTable.setValue(String.valueOf(entry.getValue()), String.valueOf(entry.getKey()));
                             }
                         } else {
                             // assign each value in the input collection to the primary key field of a new JCO.Table row
                             // (the primary key field is defined in the input list mapping)
                             inputTable.setValue(String.valueOf(value), inputListMapping.getPrimaryKey());
                         }
                     }
                 }
             }
         }
     }
 
     private void prepareFunctionInput(SapBapiMapping sapBapiMapping, Map input, JCO.Function function) {
         // Prepare input parameters for SAP function call
         for (int j = 0; j < sapBapiMapping.getInput().size(); j++) {
             SapInput sapInput = (SapInput) sapBapiMapping.getInput().get(j);
             String value = (String) input.get(sapInput.getName());
             if ((value == null || value.trim().length() == 0) && sapInput.isRequired()) {
                 if (sapInput.getDefaultValue() != null && sapInput.getDefaultValue().length() > 0) {
                     value = sapInput.getDefaultValue();
                 } else {
                     throw new SapJcoMappingException("Missing input parameter '" + sapInput
                             .getName() + "' (required and no default value supplied)");
                 }
             }
             if (logger.isDebugEnabled()) {
                 logger.debug(new StringBuffer("Setting import parameter '").append(sapInput.getName()).append("' to '")
                         .append(value).append("'"));
             }
             function.getImportParameterList().setValue(value, sapInput.getName());
         }
     }
 
 
     /**
      * This helper method creates a new <code>JCO.Table</code> instance that contains
      * all rows of the parent table which have a value of <code>pkValue</code> for field <code>pkField</code>.
      *
      * @param table   table to sort
      * @param pkField name of the primary key field
      * @param pkValue value against which rows are filtered
      * @return new instance of JCO.Table containing all but the filtered rows
      */
     private JCO.Table filterTable(JCO.Table table, String pkField, String pkValue) {
         JCO.Table subTable = new JCO.Table(table.getMetaData());
         table.firstRow();
         do {
             if (pkValue.equals(table.getString(pkField))) {
                 // copy current row
                 subTable.appendRow();
                 for (int counter = 0; counter < table.getNumColumns(); counter++) {
                     subTable.setValue(table.getValue(counter), counter);
                 }
             }
         } while (table.nextRow());
         return subTable;
     }
 
     /**
      * This helper method checks if a JCO.Field instance that is mapped as a table is actually a JCO.Table
      *
      * @param field field to check
      * @return JCO.Field cast to JCO.Table
      * @throws SapJcoMappingException if the <code>JCO.Field</code> is not a <code>JCO.Table</code>
      */
     private JCO.Table checkAndGetTable(JCO.Field field) throws SapJcoMappingException {
         if (!field.isTable()) {
             throw new SapJcoMappingException(new StringBuffer("Field ").append(field.getName()).append(
                     " is mapped as table but isn't one").toString());
         }
         return field.getTable();
     }
 
     private JCO.Field getField(JCO.Function function, String name) {
         JCO.ParameterList output = function.getExportParameterList();
         if (output != null && output.hasField(name)) {
             return output.getField(name);
         }
         output = function.getTableParameterList();
         if (output != null && output.hasField(name)) {
             return output.getField(name);
         }
         return null;
     }
 
     protected List retrieve(Class persistentObject, List inputMaps) {
         return retrieve(persistentObject, inputMaps, null);
     }
 
     protected List retrieve(Class persistentObject, List inputMaps, String profile) {
         if (persistentObject == null) {
             throw new IllegalArgumentException("'persistentObject' parameter is required.");
         }
         if (inputMaps == null || inputMaps.size() == 0) {
             //nothing to fetch, so return an empty list
             return new ArrayList(0);
         }
 
         //create threadpool and call retrieve parellel...
         PooledExecutor pool = new PooledExecutor(maxParallelCalls);
         pool.setMaximumPoolSize(maxParallelCalls);
         pool.setMinimumPoolSize(1);
         pool.waitWhenBlocked();
 
         logger.warn("Using internal thread pool to execute " + inputMaps.size() + " requests in parallel");
         try {
             List results = new ArrayList(inputMaps.size());
             List calls = new ArrayList(inputMaps.size());
             for (int i = 0; i < inputMaps.size(); i++) {
                 Map input = (Map) inputMaps.get(i);
                 AsyncRetrieveCall call = new AsyncRetrieveCall(persistentObject, input, profile);
                 calls.add(call);
                 pool.execute(call);
             }
             for (int i = 0; i < calls.size(); i++) {
                 AsyncRetrieveCall asyncRetrieveCall = (AsyncRetrieveCall) calls.get(i);
                 Object result = asyncRetrieveCall.getMethodReturnValue();
                 if (result != null) {
                     results.add(result);
                 }
             }
             return results;
         } catch (InterruptedException e) {
             throw new DataRetrievalFailureException("The request has been interrupted by the system", e);
         }
     }
 
     protected Object retrieve(Class persistentObject, Map input) {
         return retrieve(persistentObject, input, null);
     }
 
     /**
      * Retrieves value objects of type <code>persistentObject</code>.
      * <p/>
      * The <code>input</code> parameter specifies the input paramters that should be passed to SAP.
      * If the result of this call will be one value object, the entries in the Map will be mapped to SAP call import parameters.
      * If the result of this call is a List of value Objects, and a SAP input table is used rather than import parameters,
      * the Map contains a Collection as well. The key of this Collection is the same as the SAP input table.
      * <p/>
      * This Collection can contain two types of values.
      * <ol>
      * <li>
      * The elements of the collection contain a value that should be assigned to the primary key field of the table,
      * which is defined in the input list mapping. Each value of in the collection will be assigned to the primary
      * key of a new <code>JCO.Table</code> row
      * </li>
      * <li>
      * The elements of the collection contain a Map. The keys of this Map should correspond exactly to the SAP
      * fields and the values will be assigned to these fields. Every Map in the collection correspond to
      * one <code>JCO.Table</code> row.
      * </li>
      * </ol>
      * <p/>
      * Here is an example of the second situation: a <code>Collection of Maps</code>.
      * Each map can contain a different number of field/value pairs to process.
      * <pre>
      * Collection
      *    0 - Map
      *       * DOCUMENT_NUMBER -> value
      *    1 - Map
      *       * DOCUMENT_NUMBER -> value
      *       * DOCUMENT_TYPE -> value
      *    2 - Map
      *       * MATERIAL -> value
      *       * DOCUMENT_NUMBER -> value
      *       * DOCUMENT_TYPE -> value
      *    etc.
      * </pre>
      *
      * @param persistentObject type of the value object
      * @param input            input map
      * @param profile          name to retrieve fields for
      * @return - one single value object of type <code>persistentObject</code>
      *         <br/>   - or a List of value objects of type <code>persistentObject</code> if the SAP call supports input/output tables
      */
     protected Object retrieve(Class persistentObject, Map input, String profile) {
         if (persistentObject == null) {
             throw new IllegalArgumentException("'persistentObject' parameter is required.");
         }
         if (input == null) {
             input = new HashMap(0);
         }
         try {
             //first validate the mapping...
             SapMapping sapMapping = SapMappingParser.getInfo(persistentObject);
             return performSapCall(sapMapping, input, persistentObject, profile);
         } catch (Exception e) {
             throw new DataRetrievalFailureException("Error fetching data", e);
         }
     }
 
     protected void checkReturnStructure(JCO.Function function) throws DataRetrievalFailureException {
         if (function.getExportParameterList() != null && function.getExportParameterList().hasField("RETURN")) {
             JCO.Structure returnStructure = function.getExportParameterList().getStructure("RETURN");
             if (! ("".equals(returnStructure.getString("TYPE")) ||
                     "S".equals(returnStructure.getString("TYPE")) ||
                     "W".equals(returnStructure.getString("TYPE")))) {
                 throw new DataRetrievalFailureException(new StringBuffer(returnStructure.getString("TYPE"))
                         .append(": ").append(returnStructure.getString("MESSAGE")).toString());
             }
         }
     }
 
     protected void mapRecordToEntity(Class entityDef, Object entity, JCO.Record record,
                                      SapStructureMapping structureMapping) {
         for (Iterator fieldsIt = structureMapping.getFields().iterator(); fieldsIt.hasNext();) {
             SapFieldMapping sapFieldMapping = (SapFieldMapping) fieldsIt.next();
             mapOneField(entityDef, entity, record, sapFieldMapping);
         }
     }
 
     protected void mapOneField(Class entityDef, Object entity, JCO.Record record, SapFieldMapping sapFieldMapping) {
         try {
             if (logger.isDebugEnabled()) {
                 logger.debug(
                         "Mapping property '" + sapFieldMapping.getPropertyName() + "' from field '" + sapFieldMapping
                                 .getFieldName() + "'");
             }
             MethodInvoker invoker = reflectionCache.getCachedInvoker(sapFieldMapping);
 //            MethodInvoker invoker = null;
             JCO.Field sapField = record.getField(sapFieldMapping.getFieldName());
             if (invoker == null) {
                 SapType type = SapType.getEnum(sapFieldMapping.getType());
                 if (type == null) {
                     throw new SapJcoMappingException(new StringBuffer("Invalid type '").append(
                             sapFieldMapping.getType()).append("'").toString());
                 }
                 invoker = new MethodInvoker();
                 invoker.setTargetClass(sapField.getClass());
                 invoker.setTargetMethod("get" + type.getName());
                 reflectionCache.cacheInvoker(sapFieldMapping, invoker);
             }
             Object value = null;
             synchronized (invoker) {
                 invoker.setTargetObject(sapField);
                 invoker.prepare();
                 try {
                     value = invoker.invoke();
                 } catch (InvocationTargetException e) {
                     String stringValue = String.valueOf(value);
                     if (JCO.ConversionException.class.equals(e.getTargetException().getClass())) {
                         //conversion failed...
                         if (value == null || stringValue.length() == 0 || "?".equalsIgnoreCase(stringValue)) {
                             value = null;
                         } else {
                             throw (JCO.ConversionException) e.getTargetException();
                         }
                     }
                 }
             }
             String stringValue = String.valueOf(value);
             if (value != null && stringValue.length() > 0 && !"?".equals(stringValue)) {
                 Field classField = reflectionCache.getCachedField(sapFieldMapping);
 //                Field classField = null;
                 if (classField == null) {
                     classField = entityDef.getDeclaredField(sapFieldMapping.getPropertyName());
                     classField.setAccessible(true);
                     reflectionCache.cacheField(sapFieldMapping, classField);
                 }
                 classField.set(entity, value);
             }
         } catch (Exception e) {
             String msg = new StringBuffer("Error mapping property '")
                     .append(sapFieldMapping.getPropertyName())
                     .append("'").toString();
             logger.error(msg, e);
             throw new SapJcoMappingException(msg, e);
         }
     }
 
     protected void convertMap(JCO.Table table, Object entity, SapStructureMapping sapStructureMapping,
                               Class persistentObject) {
         // ok this is fishy, we have to do some sort of inverse mapping
         // a structure with type map means that in SAP we have a key,value pair set of rows that are returned
         // in java we want to map them on individual properties(the XML defines which key belongs to which property...)
         table.firstRow();
         do {
             String currentKey = table.getString(sapStructureMapping.getKeyField());
             SapFieldMapping fieldMapping = (SapFieldMapping) sapStructureMapping.getFieldsMap().get(currentKey);
             if (fieldMapping != null) {
                 mapOneField(persistentObject, entity, table, fieldMapping);
             } else {
                 if (logger.isDebugEnabled()) {
                     logger.debug(
                             "No field mapping found for map structure or field is primary key of list_of_maps; key=" + currentKey);
                 }
             }
         } while (table.nextRow());
     }
 
     private Object instantiate(Class clazz) throws InstantiationException {
         try {
             if (clazz.getName().indexOf("$") > 0) {
                 String parentClassname = clazz.getName().substring(0, clazz.getName().indexOf("$"));
                 Class parentClass = Class.forName(parentClassname);
                 //inner class
                 Constructor constructor = clazz.getConstructor(new Class[]{parentClass});
                 if (constructor == null) {
                     throw new InstantiationException("Error instantiating inner class");
                 }
                 return constructor.newInstance(new Object[]{parentClass.newInstance()});
             } else {
                 return clazz.newInstance();
             }
         } catch (Exception e) {
             logger.error("Error creating new instance", e);
             throw new InstantiationException("Error creating new instance");
         }
     }
 }