package org.apache.ojb.broker.accesslayer;

 /* Copyright 2002-2005 The Apache Software Foundation

  *

  * Licensed under the Apache License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at

  *

  *     http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 import java.sql.CallableStatement;

 import java.sql.PreparedStatement;

 import java.sql.ResultSet;

 import java.sql.SQLException;

 import java.sql.Statement;

 import java.sql.Types;

 import java.util.Collection;

 import java.util.Enumeration;

 import java.util.Iterator;

 import org.apache.ojb.broker.Identity;

 import org.apache.ojb.broker.PersistenceBroker;

 import org.apache.ojb.broker.PersistenceBrokerException;

 import org.apache.ojb.broker.PersistenceBrokerSQLException;

 import org.apache.ojb.broker.core.ValueContainer;

 import org.apache.ojb.broker.metadata.ArgumentDescriptor;

 import org.apache.ojb.broker.metadata.ClassDescriptor;

 import org.apache.ojb.broker.metadata.FieldDescriptor;

 import org.apache.ojb.broker.metadata.ProcedureDescriptor;

 import org.apache.ojb.broker.platforms.Platform;

 import org.apache.ojb.broker.platforms.PlatformException;

 import org.apache.ojb.broker.platforms.PlatformFactory;

 import org.apache.ojb.broker.query.BetweenCriteria;

 import org.apache.ojb.broker.query.Criteria;

 import org.apache.ojb.broker.query.ExistsCriteria;

 import org.apache.ojb.broker.query.FieldCriteria;

 import org.apache.ojb.broker.query.InCriteria;

 import org.apache.ojb.broker.query.NullCriteria;

 import org.apache.ojb.broker.query.Query;

 import org.apache.ojb.broker.query.SelectionCriteria;

 import org.apache.ojb.broker.query.SqlCriteria;

 import org.apache.ojb.broker.util.logging.Logger;

 import org.apache.ojb.broker.util.logging.LoggerFactory;

 /**

  * manages JDBC Connection and Statement resources.

  *

  * @author Thomas Mahler

  * @author <a href="mailto:rburt3@mchsi.com">Randall Burt</a>

  * @version $Id: StatementManager.java,v 1.1 2007-08-24 22:17:30 ewestfal Exp $

  */

 public class StatementManager implements StatementManagerIF

 {

     private Logger m_log = LoggerFactory.getLogger(StatementManager.class);

     /** the associated broker */

     private final PersistenceBroker m_broker;

     private Platform m_platform;

     /**

      * Used when OJB run in JBoss

      * TODO: Find a better solution to handle OJB within JBoss

      * --> the JCA implementation should solve this problem

      *

      * arminw:

      * Seems with JBoss 3.2.2 or higher the problem is gone, so we

      * can deprecate this attribute sooner or later

      */

     private boolean m_eagerRelease;

     private ConnectionManagerIF m_conMan;

     public StatementManager(final PersistenceBroker pBroker)

     {

         this.m_broker = pBroker;

         this.m_conMan = m_broker.serviceConnectionManager();

         m_eagerRelease = m_conMan.getConnectionDescriptor().getEagerRelease();

         m_platform = PlatformFactory.getPlatformFor(m_conMan.getConnectionDescriptor());

     }

     public void closeResources(Statement stmt, ResultSet rs)

     {

         if (m_log.isDebugEnabled())

             m_log.debug("closeResources was called");

         try

         {

             m_platform.beforeStatementClose(stmt, rs);

             //close statement on wrapped statement class, or real statement

             if (stmt != null)

             {

                 //log.info("## close: "+stmt);

                 stmt.close();

                 /*

                 *********************************************

                 special stuff for OJB within JBoss

                 ********************************************

                 */

                 if (m_eagerRelease)

                 {

                     m_conMan.releaseConnection();

                 }

             }

             m_platform.afterStatementClose(stmt, rs);

         }

         catch (PlatformException e)

         {

             m_log.error("Platform dependent operation failed", e);

         }

         catch (SQLException ignored)

         {

             if (m_log.isDebugEnabled())

                 m_log.debug("Statement closing failed", ignored);

         }

     }

     /**

      * binds the Identities Primary key values to the statement

      */

     public void bindDelete(PreparedStatement stmt, Identity oid, ClassDescriptor cld) throws SQLException

     {

         Object[] pkValues = oid.getPrimaryKeyValues();

         FieldDescriptor[] pkFields = cld.getPkFields();

         int i = 0;

         try

         {

             for (; i < pkValues.length; i++)

             {

                 setObjectForStatement(stmt, i + 1, pkValues[i], pkFields[i].getJdbcType().getType());

             }

         }

         catch (SQLException e)

         {

             m_log.error("bindDelete failed for: " + oid.toString() + ", while set value '" +

                     pkValues[i] + "' for column " + pkFields[i].getColumnName());

             throw e;

         }

     }

     /**

      * binds the objects primary key and locking values to the statement, BRJ

      */

     public void bindDelete(PreparedStatement stmt, ClassDescriptor cld, Object obj) throws SQLException

     {

         if (cld.getDeleteProcedure() != null)

         {

             this.bindProcedure(stmt, cld, obj, cld.getDeleteProcedure());

         }

         else

         {

             int index = 1;

             ValueContainer[] values, currentLockingValues;

             currentLockingValues = cld.getCurrentLockingValues(obj);

             // parameters for WHERE-clause pk

             values = getKeyValues(m_broker, cld, obj);

             for (int i = 0; i < values.length; i++)

             {

                 setObjectForStatement(stmt, index, values[i].getValue(), values[i].getJdbcType().getType());

                 index++;

             }

             // parameters for WHERE-clause locking

             values = currentLockingValues;

             for (int i = 0; i < values.length; i++)

             {

                 setObjectForStatement(stmt, index, values[i].getValue(), values[i].getJdbcType().getType());

                 index++;

             }

         }

     }

     /**

      * bind attribute and value

      * @param stmt

      * @param index

      * @param attributeOrQuery

      * @param value

      * @param cld

      * @return

      * @throws SQLException

      */

     private int bindStatementValue(PreparedStatement stmt, int index, Object attributeOrQuery, Object value, ClassDescriptor cld)

             throws SQLException

     {

         FieldDescriptor fld = null;

         // if value is a subQuery bind it

         if (value instanceof Query)

         {

             Query subQuery = (Query) value;

             return bindStatement(stmt, subQuery, cld.getRepository().getDescriptorFor(subQuery.getSearchClass()), index);

         }

         // if attribute is a subQuery bind it

         if (attributeOrQuery instanceof Query)

         {

             Query subQuery = (Query) attributeOrQuery;

             bindStatement(stmt, subQuery, cld.getRepository().getDescriptorFor(subQuery.getSearchClass()), index);

         }

         else

         {

             fld = cld.getFieldDescriptorForPath((String) attributeOrQuery);

         }

         if (fld != null)

         {

             // BRJ: use field conversions and platform

             if (value != null)

             {

                 m_platform.setObjectForStatement(stmt, index, fld.getFieldConversion().javaToSql(value), fld.getJdbcType().getType());

             }

             else

             {

                 m_platform.setNullForStatement(stmt, index, fld.getJdbcType().getType());

             }

         }

         else

         {

             if (value != null)

             {

                 stmt.setObject(index, value);

             }

             else

             {

                 stmt.setNull(index, Types.NULL);

             }

         }

         return ++index; // increment before return

     }

     /**

      * bind SelectionCriteria

      * @param stmt the PreparedStatement

      * @param index the position of the parameter to bind

      * @param crit the Criteria containing the parameter

      * @param cld the ClassDescriptor

      * @return next index for PreparedStatement

      */

     private int bindStatement(PreparedStatement stmt, int index, SelectionCriteria crit, ClassDescriptor cld) throws SQLException

     {

         return bindStatementValue(stmt, index, crit.getAttribute(), crit.getValue(), cld);

     }

     /**

      * bind NullCriteria

      * @param stmt the PreparedStatement

      * @param index the position of the parameter to bind

      * @param crit the Criteria containing the parameter

      * @return next index for PreparedStatement

      */

     private int bindStatement(PreparedStatement stmt, int index, NullCriteria crit)

     {

         return index;

     }

     /**

      * bind FieldCriteria

      * @param stmt , the PreparedStatement

      * @param index , the position of the parameter to bind

      * @param crit , the Criteria containing the parameter

      * @return next index for PreparedStatement

      */

     private int bindStatement(PreparedStatement stmt, int index, FieldCriteria crit)

     {

         return index;

     }

     /**

      * bind SqlCriteria

      * @param stmt the PreparedStatement

      * @param index the position of the parameter to bind

      * @param crit the Criteria containing the parameter

      * @return next index for PreparedStatement

      */

     private int bindStatement(PreparedStatement stmt, int index, SqlCriteria crit)

     {

         return index;

     }

     /**

      * bind BetweenCriteria

      * @param stmt the PreparedStatement

      * @param index the position of the parameter to bind

      * @param crit the Criteria containing the parameter

      * @param cld the ClassDescriptor

      * @return next index for PreparedStatement

      */

     private int bindStatement(PreparedStatement stmt, int index, BetweenCriteria crit, ClassDescriptor cld) throws SQLException

     {

         index = bindStatementValue(stmt, index, crit.getAttribute(), crit.getValue(), cld);

         return bindStatementValue(stmt, index, crit.getAttribute(), crit.getValue2(), cld);

     }

     /**

      * bind InCriteria

      * @param stmt the PreparedStatement

      * @param index the position of the parameter to bind

      * @param crit the Criteria containing the parameter

      * @param cld the ClassDescriptor

      * @return next index for PreparedStatement

      */

     private int bindStatement(PreparedStatement stmt, int index, InCriteria crit, ClassDescriptor cld) throws SQLException

     {

         if (crit.getValue() instanceof Collection)

         {

             Collection values = (Collection) crit.getValue();

             Iterator iter = values.iterator();

             while (iter.hasNext())

             {

                 index = bindStatementValue(stmt, index, crit.getAttribute(), iter.next(), cld);

             }

         }

         else

         {

             index = bindStatementValue(stmt, index, crit.getAttribute(), crit.getValue(), cld);

         }

         return index;

     }

     /**

      * bind ExistsCriteria

      * @param stmt the PreparedStatement

      * @param index the position of the parameter to bind

      * @param crit the Criteria containing the parameter

      * @param cld the ClassDescriptor

      * @return next index for PreparedStatement

      */

     private int bindStatement(PreparedStatement stmt, int index, ExistsCriteria crit, ClassDescriptor cld) throws SQLException

     {

         Query subQuery = (Query) crit.getValue();

         // if query has criteria, bind them

         if (subQuery.getCriteria() != null && !subQuery.getCriteria().isEmpty())

         {

             return bindStatement(stmt, subQuery.getCriteria(), cld.getRepository().getDescriptorFor(subQuery.getSearchClass()), index);

             // otherwise, just ignore it

         }

         else

         {

             return index;

         }

     }

     /**

      * bind a Query based Select Statement

      */

     public int bindStatement(PreparedStatement stmt, Query query, ClassDescriptor cld, int param) throws SQLException

     {

         int result;

         result = bindStatement(stmt, query.getCriteria(), cld, param);

         result = bindStatement(stmt, query.getHavingCriteria(), cld, result);

         return result;

     }

     /**

      * bind a Query based Select Statement

      */

     protected int bindStatement(PreparedStatement stmt, Criteria crit, ClassDescriptor cld, int param) throws SQLException

     {

         if (crit != null)

         {

             Enumeration e = crit.getElements();

             while (e.hasMoreElements())

             {

                 Object o = e.nextElement();

                 if (o instanceof Criteria)

                 {

                     Criteria pc = (Criteria) o;

                     param = bindStatement(stmt, pc, cld, param);

                 }

                 else

                 {

                     SelectionCriteria c = (SelectionCriteria) o;

                     // BRJ : bind once for the criterion's main class

                     param = bindSelectionCriteria(stmt, param, c, cld);

                     // BRJ : and once for each extent

                     for (int i = 0; i < c.getNumberOfExtentsToBind(); i++)

                     {

                         param = bindSelectionCriteria(stmt, param, c, cld);

                     }

                 }

             }

         }

         return param;

     }

     /**

      * bind SelectionCriteria

      * @param stmt the PreparedStatement

      * @param index the position of the parameter to bind

      * @param crit the Criteria containing the parameter

      * @param cld the ClassDescriptor

      * @return next index for PreparedStatement

      */

     private int bindSelectionCriteria(PreparedStatement stmt, int index, SelectionCriteria crit, ClassDescriptor cld) throws SQLException

     {

         if (crit instanceof NullCriteria)

             index = bindStatement(stmt, index, (NullCriteria) crit);

         else if (crit instanceof BetweenCriteria)

             index = bindStatement(stmt, index, (BetweenCriteria) crit, cld);

         else if (crit instanceof InCriteria)

             index = bindStatement(stmt, index, (InCriteria) crit, cld);

         else if (crit instanceof SqlCriteria)

             index = bindStatement(stmt, index, (SqlCriteria) crit);

         else if (crit instanceof FieldCriteria)

             index = bindStatement(stmt, index, (FieldCriteria) crit);

         else if (crit instanceof ExistsCriteria)

             index = bindStatement(stmt, index, (ExistsCriteria) crit, cld);

         else

             index = bindStatement(stmt, index, crit, cld);

         return index;

     }

     /**

      * binds the values of the object obj to the statements parameters

      */

     public void bindInsert(PreparedStatement stmt, ClassDescriptor cld, Object obj) throws java.sql.SQLException

     {

         ValueContainer[] values;

         cld.updateLockingValues(obj); // BRJ : provide useful defaults for locking fields

         if (cld.getInsertProcedure() != null)

         {

             this.bindProcedure(stmt, cld, obj, cld.getInsertProcedure());

         }

         else

         {

             values = getAllValues(cld, obj);

             for (int i = 0; i < values.length; i++)

             {

                 setObjectForStatement(stmt, i + 1, values[i].getValue(), values[i].getJdbcType().getType());

             }

         }

     }

     /**

      * Binds the Identities Primary key values to the statement.

      */

     public void bindSelect(PreparedStatement stmt, Identity oid, ClassDescriptor cld, boolean callableStmt) throws SQLException

     {

         ValueContainer[] values = null;

         int i = 0;

         int j = 0;

         if (cld == null)

         {

             cld = m_broker.getClassDescriptor(oid.getObjectsRealClass());

         }

         try

         {

             if(callableStmt)

             {

                 // First argument is the result set

                 m_platform.registerOutResultSet((CallableStatement) stmt, 1);

                 j++;

             }

             values = getKeyValues(m_broker, cld, oid);

             for (/*void*/; i < values.length; i++, j++)

             {

                 setObjectForStatement(stmt, j + 1, values[i].getValue(), values[i].getJdbcType().getType());

             }

         }

         catch (SQLException e)

         {

             m_log.error("bindSelect failed for: " + oid.toString() + ", PK: " + i + ", value: " + values[i]);

             throw e;

         }

     }

     /**

      * binds the values of the object obj to the statements parameters

      */

     public void bindUpdate(PreparedStatement stmt, ClassDescriptor cld, Object obj) throws java.sql.SQLException

     {

         if (cld.getUpdateProcedure() != null)

         {

             this.bindProcedure(stmt, cld, obj, cld.getUpdateProcedure());

         }

         else

         {

             int index = 1;

             ValueContainer[] values, valuesSnapshot;

             // first take a snapshot of current locking values

             valuesSnapshot = cld.getCurrentLockingValues(obj);

             cld.updateLockingValues(obj); // BRJ

             values = getNonKeyValues(m_broker, cld, obj);

             // parameters for SET-clause

             for (int i = 0; i < values.length; i++)

             {

                 setObjectForStatement(stmt, index, values[i].getValue(), values[i].getJdbcType().getType());

                 index++;

             }

             // parameters for WHERE-clause pk

             values = getKeyValues(m_broker, cld, obj);

             for (int i = 0; i < values.length; i++)

             {

                 setObjectForStatement(stmt, index, values[i].getValue(), values[i].getJdbcType().getType());

                 index++;

             }

             // parameters for WHERE-clause locking

             // take old locking values

             values = valuesSnapshot;

             for (int i = 0; i < values.length; i++)

             {

                 setObjectForStatement(stmt, index, values[i].getValue(), values[i].getJdbcType().getType());

                 index++;

             }

         }

     }

     /**

      * binds the given array of values (if not null) starting from the given

      * parameter index

      * @return the next parameter index

      */

     public int bindValues(PreparedStatement stmt, ValueContainer[] values, int index) throws SQLException

     {

         if (values != null)

         {

             for (int i = 0; i < values.length; i++)

             {

                 setObjectForStatement(stmt, index, values[i].getValue(), values[i].getJdbcType().getType());

                 index++;

             }

         }

         return index;

     }

     /**

      * return a prepared DELETE Statement fitting for the given ClassDescriptor

      */

     public PreparedStatement getDeleteStatement(ClassDescriptor cld) throws PersistenceBrokerSQLException, PersistenceBrokerException

     {

         try

         {

             return cld.getStatementsForClass(m_conMan).getDeleteStmt(m_conMan.getConnection());

         }

         catch (SQLException e)

         {

             throw new PersistenceBrokerSQLException("Could not build statement ask for", e);

         }

         catch (LookupException e)

         {

             throw new PersistenceBrokerException("Used ConnectionManager instance could not obtain a connection", e);

         }

     }

     /**

      * return a generic Statement for the given ClassDescriptor.

      * Never use this method for UPDATE/INSERT/DELETE if you want to use the batch mode.

      */

     public Statement getGenericStatement(ClassDescriptor cds, boolean scrollable) throws PersistenceBrokerException

     {

         try

         {

             return cds.getStatementsForClass(m_conMan).getGenericStmt(m_conMan.getConnection(), scrollable);

         }

         catch (LookupException e)

         {

             throw new PersistenceBrokerException("Used ConnectionManager instance could not obtain a connection", e);

         }

     }

     /**

      * return a prepared Insert Statement fitting for the given ClassDescriptor

      */

     public PreparedStatement getInsertStatement(ClassDescriptor cds) throws PersistenceBrokerSQLException, PersistenceBrokerException

     {

         try

         {

             return cds.getStatementsForClass(m_conMan).getInsertStmt(m_conMan.getConnection());

         }

         catch (SQLException e)

         {

             throw new PersistenceBrokerSQLException("Could not build statement ask for", e);

         }

         catch (LookupException e)

         {

             throw new PersistenceBrokerException("Used ConnectionManager instance could not obtain a connection", e);

         }

     }

     /**

      * return a generic Statement for the given ClassDescriptor

      */

     public PreparedStatement getPreparedStatement(ClassDescriptor cds, String sql,

                                                   boolean scrollable, int explicitFetchSizeHint, boolean callableStmt)

             throws PersistenceBrokerException

     {

         try

         {

             return cds.getStatementsForClass(m_conMan).getPreparedStmt(m_conMan.getConnection(), sql, scrollable, explicitFetchSizeHint, callableStmt);

         }

         catch (LookupException e)

         {

             throw new PersistenceBrokerException("Used ConnectionManager instance could not obtain a connection", e);

         }

     }

     /**

      * return a prepared Select Statement for the given ClassDescriptor

      */

     public PreparedStatement getSelectByPKStatement(ClassDescriptor cds) throws PersistenceBrokerSQLException, PersistenceBrokerException

     {

         try

         {

             return cds.getStatementsForClass(m_conMan).getSelectByPKStmt(m_conMan.getConnection());

         }

         catch (SQLException e)

         {

             throw new PersistenceBrokerSQLException("Could not build statement ask for", e);

         }

         catch (LookupException e)

         {

             throw new PersistenceBrokerException("Used ConnectionManager instance could not obtain a connection", e);

         }

     }

     /**

      * return a prepared Update Statement fitting to the given ClassDescriptor

      */

     public PreparedStatement getUpdateStatement(ClassDescriptor cds) throws PersistenceBrokerSQLException, PersistenceBrokerException

     {

         try

         {

             return cds.getStatementsForClass(m_conMan).getUpdateStmt(m_conMan.getConnection());

         }

         catch (SQLException e)

         {

             throw new PersistenceBrokerSQLException("Could not build statement ask for", e);

         }

         catch (LookupException e)

         {

             throw new PersistenceBrokerException("Used ConnectionManager instance could not obtain a connection", e);

         }

     }

     /**

      * returns an array containing values for all the Objects attribute

      * @throws PersistenceBrokerException if there is an erros accessing obj field values

      */

     protected ValueContainer[] getAllValues(ClassDescriptor cld, Object obj) throws PersistenceBrokerException

     {

         return m_broker.serviceBrokerHelper().getAllRwValues(cld, obj);

     }

     /**

      * returns an Array with an Objects PK VALUES

      * @throws PersistenceBrokerException if there is an erros accessing o field values

      */

     protected ValueContainer[] getKeyValues(PersistenceBroker broker, ClassDescriptor cld, Object obj) throws PersistenceBrokerException

     {

         return broker.serviceBrokerHelper().getKeyValues(cld, obj);

     }

     /**

      * returns an Array with an Identities PK VALUES

      * @throws PersistenceBrokerException if there is an erros accessing o field values

      */

     protected ValueContainer[] getKeyValues(PersistenceBroker broker, ClassDescriptor cld, Identity oid) throws PersistenceBrokerException

     {

         return broker.serviceBrokerHelper().getKeyValues(cld, oid);

     }

     /**

      * returns an Array with an Objects NON-PK VALUES

      * @throws PersistenceBrokerException if there is an erros accessing o field values

      */

     protected ValueContainer[] getNonKeyValues(PersistenceBroker broker, ClassDescriptor cld, Object obj) throws PersistenceBrokerException

     {

         return broker.serviceBrokerHelper().getNonKeyRwValues(cld, obj);

     }

     /**

      * Bind a prepared statment that represents a call to a procedure or

      * user-defined function.

      *

      * @param stmt the statement to bind.

      * @param cld the class descriptor of the object that triggered the

      *        invocation of the procedure or user-defined function.

      * @param obj the object that triggered the invocation of the procedure

      *        or user-defined function.

      * @param proc the procedure descriptor that provides information about

      *        the arguments that shoudl be passed to the procedure or

      *        user-defined function

      */

     private void bindProcedure(PreparedStatement stmt, ClassDescriptor cld, Object obj, ProcedureDescriptor proc)

             throws SQLException

     {

         int valueSub = 0;

         // Figure out if we are using a callable statement.  If we are, then we

         // will need to register one or more output parameters.

         CallableStatement callable = null;

         try

         {

             callable = (CallableStatement) stmt;

         }

         catch(Exception e)

         {

             m_log.error("Error while bind values for class '" + (cld != null ? cld.getClassNameOfObject() : null)

                     + "', using stored procedure: "+ proc, e);

             if(e instanceof SQLException)

             {

                 throw (SQLException) e;

             }

             else

             {

                 throw new PersistenceBrokerException("Unexpected error while bind values for class '"

                         + (cld != null ? cld.getClassNameOfObject() : null) + "', using stored procedure: "+ proc);

             }

         }

         // If we have a return value, then register it.

         if ((proc.hasReturnValue()) && (callable != null))

         {

             int jdbcType = proc.getReturnValueFieldRef().getJdbcType().getType();

             m_platform.setNullForStatement(stmt, valueSub + 1, jdbcType);

             callable.registerOutParameter(valueSub + 1, jdbcType);

             valueSub++;

         }

         // Process all of the arguments.

         Iterator iterator = proc.getArguments().iterator();

         while (iterator.hasNext())

         {

             ArgumentDescriptor arg = (ArgumentDescriptor) iterator.next();

             Object val = arg.getValue(obj);

             int jdbcType = arg.getJdbcType();

             setObjectForStatement(stmt, valueSub + 1, val, jdbcType);

             if ((arg.getIsReturnedByProcedure()) && (callable != null))

             {

                 callable.registerOutParameter(valueSub + 1, jdbcType);

             }

             valueSub++;

         }

     }

     /**

      * Sets object for statement at specific index, adhering to platform- and null-rules.

      * @param stmt the statement

      * @param index the current parameter index

      * @param value the value to set

      * @param sqlType the JDBC SQL-type of the value

      * @throws SQLException on platform error

      */

     private void setObjectForStatement(PreparedStatement stmt, int index, Object value, int sqlType)

             throws SQLException

     {

         if (value == null)

         {

             m_platform.setNullForStatement(stmt, index, sqlType);

         }

         else

         {

             m_platform.setObjectForStatement(stmt, index, value, sqlType);

         }

     }

 }