gt:             objs = new LinkedList();
context: package net.idtoki.serteca.model;
  
  import java.math.BigDecimal;
  import java.sql.Connection;
  import java.sql.SQLException;
  import java.util.ArrayList;
  import java.util.Date;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  
  import org.apache.torque.NoRowsException;
  import org.apache.torque.TooManyRowsException;
  import org.apache.torque.Torque;
  import org.apache.torque.TorqueException;
  import org.apache.torque.map.MapBuilder;
  import org.apache.torque.map.TableMap;
  import org.apache.torque.om.DateKey;
  import org.apache.torque.om.NumberKey;
  import org.apache.torque.om.StringKey;
  import org.apache.torque.om.ObjectKey;
  import org.apache.torque.om.SimpleKey;
  import org.apache.torque.util.BasePeer;
  import org.apache.torque.util.Criteria;
  
  import com.workingdogs.village.DataSetException;
  import com.workingdogs.village.QueryDataSet;
  import com.workingdogs.village.Record;
  
  // Local classes
  import net.idtoki.serteca.model.map.*;
  
  
    
    
  /**
   * This class was autogenerated by Torque on:
   *
   * [Mon Jul 03 11:03:24 CEST 2006]
   *
   */
  public abstract class BaseVehiculoPeer
      extends BasePeer
  {
  
      /** the default database name for this class */
      public static final String DATABASE_NAME = "SERTECA-DB";
  
       /** the table name for this class */
      public static final String TABLE_NAME = "Vehiculos";
  
      /**
       * @return the map builder for this peer
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static MapBuilder getMapBuilder()
          throws TorqueException
      {
          return getMapBuilder(VehiculoMapBuilder.CLASS_NAME);
      }
  
        /** the column name for the ID field */
      public static final String ID;
        /** the column name for the MODELO_ID field */
      public static final String MODELO_ID;
        /** the column name for the VERSION field */
      public static final String VERSION;
        /** the column name for the MATRICULA field */
      public static final String MATRICULA;
        /** the column name for the CLIENTE_ID field */
      public static final String CLIENTE_ID;
        /** the column name for the CHASIS_ID field */
      public static final String CHASIS_ID;
        /** the column name for the MOTOR_ID field */
      public static final String MOTOR_ID;
        /** the column name for the COLOR field */
      public static final String COLOR;
        /** the column name for the FECHA_MATRICULACION field */
      public static final String FECHA_MATRICULACION;
        /** the column name for the FECHA_REVISION field */
      public static final String FECHA_REVISION;
        /** the column name for the OBSERVACION field */
      public static final String OBSERVACION;
    
      static
      {
            ID = "Vehiculos.ID";
            MODELO_ID = "Vehiculos.MODELO_ID";
            VERSION = "Vehiculos.VERSION";
            MATRICULA = "Vehiculos.MATRICULA";
            CLIENTE_ID = "Vehiculos.CLIENTE_ID";
            CHASIS_ID = "Vehiculos.CHASIS_ID";
            MOTOR_ID = "Vehiculos.MOTOR_ID";
            COLOR = "Vehiculos.COLOR";
            FECHA_MATRICULACION = "Vehiculos.FECHA_MATRICULACION";
            FECHA_REVISION = "Vehiculos.FECHA_REVISION";
            OBSERVACION = "Vehiculos.OBSERVACION";
            if (Torque.isInit())
          {
              try
              {
                  getMapBuilder(VehiculoMapBuilder.CLASS_NAME);
              }
              catch (Exception e)
              {
                  log.error("Could not initialize Peer", e);
              }
          }
          else
          {
              Torque.registerMapBuilder(VehiculoMapBuilder.CLASS_NAME);
          }
      }
   
      /** number of columns for this peer */
      public static final int numColumns =  11;
  
      /** A class that can be returned by this peer. */
      protected static final String CLASSNAME_DEFAULT =
          "net.idtoki.serteca.model.Vehiculo";
  
      /** A class that can be returned by this peer. */
      protected static final Class CLASS_DEFAULT = initClass(CLASSNAME_DEFAULT);
  
      /**
       * Class object initialization method.
       *
       * @param className name of the class to initialize
       * @return the initialized class
       */
      private static Class initClass(String className)
      {
          Class c = null;
          try
          {
              c = Class.forName(className);
          }
          catch (Throwable t)
          {
              log.error("A FATAL ERROR has occurred which should not "
                  + "have happened under any circumstance.  Please notify "
                  + "the Torque developers <torque-dev@db.apache.org> "
                  + "and give as many details as possible (including the error "
                  + "stack trace).", t);
  
              // Error objects should always be propogated.
              if (t instanceof Error)
              {
                  throw (Error) t.fillInStackTrace();
              }
          }
          return c;
      }
  
      /**
       * Get the list of objects for a ResultSet.  Please not that your
       * resultset MUST return columns in the right order.  You can use
       * getFieldNames() in BaseObject to get the correct sequence.
       *
       * @param results the ResultSet
       * @return the list of objects
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static List resultSet2Objects(java.sql.ResultSet results)
              throws TorqueException
      {
          try
          {
              QueryDataSet qds = null;
              List rows = null;
              try
              {
                  qds = new QueryDataSet(results);
                  rows = getSelectResults(qds);
              }
              finally
              {
                  if (qds != null)
                  {
                      qds.close();
                  }
              }
  
              return populateObjects(rows);
          }
          catch (SQLException e)
          {
              throw new TorqueException(e);
          }
          catch (DataSetException e)
          {
              throw new TorqueException(e);
          }
      }
  
  
    
      /**
       * Method to do inserts.
       *
       * @param criteria object used to create the INSERT statement.
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static ObjectKey doInsert(Criteria criteria)
          throws TorqueException
      {
          return BaseVehiculoPeer
              .doInsert(criteria, (Connection) null);
      }
  
      /**
       * Method to do inserts.  This method is to be used during a transaction,
       * otherwise use the doInsert(Criteria) method.  It will take care of
       * the connection details internally.
       *
       * @param criteria object used to create the INSERT statement.
       * @param con the connection to use
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static ObjectKey doInsert(Criteria criteria, Connection con)
          throws TorqueException
      {
                                                                      
          setDbName(criteria);
  
          if (con == null)
          {
              return BasePeer.doInsert(criteria);
          }
          else
          {
              return BasePeer.doInsert(criteria, con);
          }
      }
  
      /**
       * Add all the columns needed to create a new object.
       *
       * @param criteria object containing the columns to add.
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static void addSelectColumns(Criteria criteria)
              throws TorqueException
      {
            criteria.addSelectColumn(ID);
            criteria.addSelectColumn(MODELO_ID);
            criteria.addSelectColumn(VERSION);
            criteria.addSelectColumn(MATRICULA);
            criteria.addSelectColumn(CLIENTE_ID);
            criteria.addSelectColumn(CHASIS_ID);
            criteria.addSelectColumn(MOTOR_ID);
            criteria.addSelectColumn(COLOR);
            criteria.addSelectColumn(FECHA_MATRICULACION);
            criteria.addSelectColumn(FECHA_REVISION);
            criteria.addSelectColumn(OBSERVACION);
        }
  
      /**
       * Create a new object of type cls from a resultset row starting
       * from a specified offset.  This is done so that you can select
       * other rows than just those needed for this object.  You may
       * for example want to create two objects from the same row.
       *
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static Vehiculo row2Object(Record row,
                                               int offset,
                                               Class cls)
          throws TorqueException
      {
          try
          {
              Vehiculo obj = (Vehiculo) cls.newInstance();
              VehiculoPeer.populateObject(row, offset, obj);
                    obj.setModified(false);
                obj.setNew(false);
  
              return obj;
          }
          catch (InstantiationException e)
          {
              throw new TorqueException(e);
          }
          catch (IllegalAccessException e)
          {
              throw new TorqueException(e);
          }
      }
  
      /**
       * Populates an object from a resultset row starting
       * from a specified offset.  This is done so that you can select
       * other rows than just those needed for this object.  You may
       * for example want to create two objects from the same row.
       *
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static void populateObject(Record row,
                                        int offset,
                                        Vehiculo obj)
          throws TorqueException
      {
          try
          {
                  obj.setId(row.getValue(offset + 0).asInt());
                    obj.setModeloId(row.getValue(offset + 1).asInt());
                    obj.setVersion(row.getValue(offset + 2).asString());
                    obj.setMatricula(row.getValue(offset + 3).asString());
                    obj.setClienteId(row.getValue(offset + 4).asInt());
                    obj.setChasisId(row.getValue(offset + 5).asString());
                    obj.setMotorId(row.getValue(offset + 6).asString());
                    obj.setColor(row.getValue(offset + 7).asString());
                    obj.setFechaMatriculacion(row.getValue(offset + 8).asString());
                    obj.setFechaRevision(row.getValue(offset + 9).asString());
                    obj.setObs(row.getValue(offset + 10).asString());
                }
          catch (DataSetException e)
          {
              throw new TorqueException(e);
          }
      }
  
      /**
       * Method to do selects.
       *
       * @param criteria object used to create the SELECT statement.
       * @return List of selected Objects
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static List doSelect(Criteria criteria) throws TorqueException
      {
          return populateObjects(doSelectVillageRecords(criteria));
      }
  
      /**
       * Method to do selects within a transaction.
       *
       * @param criteria object used to create the SELECT statement.
       * @param con the connection to use
       * @return List of selected Objects
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static List doSelect(Criteria criteria, Connection con)
          throws TorqueException
      {
          return populateObjects(doSelectVillageRecords(criteria, con));
      }
  
      /**
       * Grabs the raw Village records to be formed into objects.
       * This method handles connections internally.  The Record objects
       * returned by this method should be considered readonly.  Do not
       * alter the data and call save(), your results may vary, but are
       * certainly likely to result in hard to track MT bugs.
       *
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static List doSelectVillageRecords(Criteria criteria)
          throws TorqueException
      {
          return BaseVehiculoPeer
              .doSelectVillageRecords(criteria, (Connection) null);
      }
  
      /**
       * Grabs the raw Village records to be formed into objects.
       * This method should be used for transactions
       *
       * @param criteria object used to create the SELECT statement.
       * @param con the connection to use
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static List doSelectVillageRecords(Criteria criteria, Connection con)
          throws TorqueException
      {
          if (criteria.getSelectColumns().size() == 0)
          {
              addSelectColumns(criteria);
          }
  
                                                                      
          setDbName(criteria);
  
          // BasePeer returns a List of Value (Village) arrays.  The array
          // order follows the order columns were placed in the Select clause.
          if (con == null)
          {
              return BasePeer.doSelect(criteria);
          }
          else
          {
              return BasePeer.doSelect(criteria, con);
          }
      }
  
      /**
       * The returned List will contain objects of the default type or
       * objects that inherit from the default.
       *
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static List populateObjects(List records)
          throws TorqueException
      {
          List results = new ArrayList(records.size());
  
          // populate the object(s)
          for (int i = 0; i < records.size(); i++)
          {
              Record row = (Record) records.get(i);
                results.add(VehiculoPeer.row2Object(row, 1,
                  VehiculoPeer.getOMClass()));
            }
          return results;
      }
   
  
      /**
       * The class that the Peer will make instances of.
       * If the BO is abstract then you must implement this method
       * in the BO.
       *
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static Class getOMClass()
          throws TorqueException
      {
          return CLASS_DEFAULT;
      }
  
      /**
       * Method to do updates.
       *
       * @param criteria object containing data that is used to create the UPDATE
       *        statement.
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static void doUpdate(Criteria criteria) throws TorqueException
      {
           BaseVehiculoPeer
              .doUpdate(criteria, (Connection) null);
      }
  
      /**
       * Method to do updates.  This method is to be used during a transaction,
       * otherwise use the doUpdate(Criteria) method.  It will take care of
       * the connection details internally.
       *
       * @param criteria object containing data that is used to create the UPDATE
       *        statement.
       * @param con the connection to use
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static void doUpdate(Criteria criteria, Connection con)
          throws TorqueException
      {
          Criteria selectCriteria = new Criteria(DATABASE_NAME, 2);
                     selectCriteria.put(ID, criteria.remove(ID));
                                                                                                            
          setDbName(criteria);
  
          if (con == null)
          {
              BasePeer.doUpdate(selectCriteria, criteria);
          }
          else
          {
              BasePeer.doUpdate(selectCriteria, criteria, con);
          }
      }
  
      /**
       * Method to do deletes.
       *
       * @param criteria object containing data that is used DELETE from database.
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
       public static void doDelete(Criteria criteria) throws TorqueException
       {
           VehiculoPeer
              .doDelete(criteria, (Connection) null);
       }
  
      /**
       * Method to do deletes.  This method is to be used during a transaction,
       * otherwise use the doDelete(Criteria) method.  It will take care of
       * the connection details internally.
       *
       * @param criteria object containing data that is used DELETE from database.
       * @param con the connection to use
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
       public static void doDelete(Criteria criteria, Connection con)
          throws TorqueException
       {
                                                                      
          setDbName(criteria);
  
          if (con == null)
          {
              BasePeer.doDelete(criteria);
          }
          else
          {
              BasePeer.doDelete(criteria, con);
          }
       }
  
      /**
       * Method to do selects
       *
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static List doSelect(Vehiculo obj) throws TorqueException
      {
          return doSelect(buildSelectCriteria(obj));
      }
  
      /**
       * Method to do inserts
       *
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static void doInsert(Vehiculo obj) throws TorqueException
      {
            obj.setPrimaryKey(doInsert(buildCriteria(obj)));
            obj.setNew(false);
          obj.setModified(false);
      }
  
      /**
       * @param obj the data object to update in the database.
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static void doUpdate(Vehiculo obj) throws TorqueException
      {
          doUpdate(buildCriteria(obj));
          obj.setModified(false);
      }
  
      /**
       * @param obj the data object to delete in the database.
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static void doDelete(Vehiculo obj) throws TorqueException
      {
          doDelete(buildSelectCriteria(obj));
      }
  
      /**
       * Method to do inserts.  This method is to be used during a transaction,
       * otherwise use the doInsert(Vehiculo) method.  It will take
       * care of the connection details internally.
       *
       * @param obj the data object to insert into the database.
       * @param con the connection to use
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static void doInsert(Vehiculo obj, Connection con)
          throws TorqueException
      {
            obj.setPrimaryKey(doInsert(buildCriteria(obj), con));
            obj.setNew(false);
          obj.setModified(false);
      }
  
      /**
       * Method to do update.  This method is to be used during a transaction,
       * otherwise use the doUpdate(Vehiculo) method.  It will take
       * care of the connection details internally.
       *
       * @param obj the data object to update in the database.
       * @param con the connection to use
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static void doUpdate(Vehiculo obj, Connection con)
          throws TorqueException
      {
          doUpdate(buildCriteria(obj), con);
          obj.setModified(false);
      }
  
      /**
       * Method to delete.  This method is to be used during a transaction,
       * otherwise use the doDelete(Vehiculo) method.  It will take
       * care of the connection details internally.
       *
       * @param obj the data object to delete in the database.
       * @param con the connection to use
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static void doDelete(Vehiculo obj, Connection con)
          throws TorqueException
      {
          doDelete(buildSelectCriteria(obj), con);
      }
  
      /**
       * Method to do deletes.
       *
       * @param pk ObjectKey that is used DELETE from database.
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static void doDelete(ObjectKey pk) throws TorqueException
      {
          BaseVehiculoPeer
             .doDelete(pk, (Connection) null);
      }
  
      /**
       * Method to delete.  This method is to be used during a transaction,
       * otherwise use the doDelete(ObjectKey) method.  It will take
       * care of the connection details internally.
       *
       * @param pk the primary key for the object to delete in the database.
       * @param con the connection to use
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static void doDelete(ObjectKey pk, Connection con)
          throws TorqueException
      {
          doDelete(buildCriteria(pk), con);
      }
  
      /** Build a Criteria object from an ObjectKey */
      public static Criteria buildCriteria( ObjectKey pk )
      {
          Criteria criteria = new Criteria();
                criteria.add(ID, pk);
            return criteria;
       }
  
      /** Build a Criteria object from the data object for this peer */
      public static Criteria buildCriteria( Vehiculo obj )
      {
          Criteria criteria = new Criteria(DATABASE_NAME);
                if (!obj.isNew())
              criteria.add(ID, obj.getId());
                criteria.add(MODELO_ID, obj.getModeloId());
                criteria.add(VERSION, obj.getVersion());
                criteria.add(MATRICULA, obj.getMatricula());
                criteria.add(CLIENTE_ID, obj.getClienteId());
                criteria.add(CHASIS_ID, obj.getChasisId());
                criteria.add(MOTOR_ID, obj.getMotorId());
                criteria.add(COLOR, obj.getColor());
                criteria.add(FECHA_MATRICULACION, obj.getFechaMatriculacion());
                criteria.add(FECHA_REVISION, obj.getFechaRevision());
                criteria.add(OBSERVACION, obj.getObs());
            return criteria;
      }
  
      /** Build a Criteria object from the data object for this peer, skipping all binary columns */
      public static Criteria buildSelectCriteria( Vehiculo obj )
      {
          Criteria criteria = new Criteria(DATABASE_NAME);
                if (!obj.isNew())
                      criteria.add(ID, obj.getId());
                            criteria.add(MODELO_ID, obj.getModeloId());
                            criteria.add(VERSION, obj.getVersion());
                            criteria.add(MATRICULA, obj.getMatricula());
                            criteria.add(CLIENTE_ID, obj.getClienteId());
                            criteria.add(CHASIS_ID, obj.getChasisId());
                            criteria.add(MOTOR_ID, obj.getMotorId());
                            criteria.add(COLOR, obj.getColor());
                            criteria.add(FECHA_MATRICULACION, obj.getFechaMatriculacion());
                            criteria.add(FECHA_REVISION, obj.getFechaRevision());
                            criteria.add(OBSERVACION, obj.getObs());
                return criteria;
      }
   
      
          /**
       * Retrieve a single object by pk
       *
       * @param pk the primary key
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       * @throws NoRowsException Primary key was not found in database.
       * @throws TooManyRowsException Primary key was not found in database.
       */
      public static Vehiculo retrieveByPK(int pk)
          throws TorqueException, NoRowsException, TooManyRowsException
      {
          return retrieveByPK(SimpleKey.keyFor(pk));
      }
  
      /**
       * Retrieve a single object by pk
       *
       * @param pk the primary key
       * @param con the connection to use
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       * @throws NoRowsException Primary key was not found in database.
       * @throws TooManyRowsException Primary key was not found in database.
       */
      public static Vehiculo retrieveByPK(int pk, Connection con)
          throws TorqueException, NoRowsException, TooManyRowsException
      {
          return retrieveByPK(SimpleKey.keyFor(pk), con);
      }
    
      /**
       * Retrieve a single object by pk
       *
       * @param pk the primary key
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       * @throws NoRowsException Primary key was not found in database.
       * @throws TooManyRowsException Primary key was not found in database.
       */
      public static Vehiculo retrieveByPK(ObjectKey pk)
          throws TorqueException, NoRowsException, TooManyRowsException
      {
          Connection db = null;
          Vehiculo retVal = null;
          try
          {
              db = Torque.getConnection(DATABASE_NAME);
              retVal = retrieveByPK(pk, db);
          }
          finally
          {
              Torque.closeConnection(db);
          }
          return(retVal);
      }
  
      /**
       * Retrieve a single object by pk
       *
       * @param pk the primary key
       * @param con the connection to use
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       * @throws NoRowsException Primary key was not found in database.
       * @throws TooManyRowsException Primary key was not found in database.
       */
      public static Vehiculo retrieveByPK(ObjectKey pk, Connection con)
          throws TorqueException, NoRowsException, TooManyRowsException
      {
          Criteria criteria = buildCriteria(pk);
          List v = doSelect(criteria, con);
          if (v.size() == 0)
          {
              throw new NoRowsException("Failed to select a row.");
          }
          else if (v.size() > 1)
          {
              throw new TooManyRowsException("Failed to select only one row.");
          }
          else
          {
              return (Vehiculo)v.get(0);
          }
      }
  
      /**
       * Retrieve a multiple objects by pk
       *
       * @param pks List of primary keys
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static List retrieveByPKs(List pks)
          throws TorqueException
      {
          Connection db = null;
          List retVal = null;
          try
          {
             db = Torque.getConnection(DATABASE_NAME);
             retVal = retrieveByPKs(pks, db);
          }
          finally
          {
              Torque.closeConnection(db);
          }
          return(retVal);
      }
  
      /**
       * Retrieve a multiple objects by pk
       *
       * @param pks List of primary keys
       * @param dbcon the connection to use
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static List retrieveByPKs( List pks, Connection dbcon )
          throws TorqueException
      {
          List objs = null;
          if (pks == null || pks.size() == 0)
          {
  