// license-header java merge-point
//
// Attention: Generated code! Do not modify by hand!
// Generated by: SpringDao.vsl in andromda-spring-cartridge.
//
package fr.ifremer.adagio.core.dao.data.measure;

/*
 * #%L
 * SIH-Adagio :: Core
 * $Id:$
 * $HeadURL:$
 * %%
 * Copyright (C) 2012 - 2014 Ifremer
 * %%
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 * #L%
 */

import fr.ifremer.adagio.core.dao.Search;
import fr.ifremer.adagio.core.dao.data.batch.Batch;
import fr.ifremer.adagio.core.dao.referential.QualityFlag;
import fr.ifremer.adagio.core.dao.referential.pmfm.Pmfm;
import java.util.Collection;
import java.util.Date;
import java.util.Set;
import org.andromda.spring.PaginationResult;

/**
 * Résultat de mesure de quantification d'un lot.
 * Les mesures de quantification portent sur le paramètre "Poids". Elle peuvent être obtenue par
 * différentes méthodes :
 * - mesuré (ex : par une règle ou Ichtyomètre),
 * - estimé (ex : jugement par un expert),
 * - calculé par une relation taille/poids
 * - calculé à partir de volumes (nombre d'unité de volume x Poids d'une unité de volume). Il s'agit
 * donc d'un poids estimé, mais par le volume.
 * - déclaré (cf SACROIS/RIC2)
 * @see QuantificationMeasurement
 */
public interface QuantificationMeasurementDao
{
    /**
     * This constant is used as a transformation flag; entities can be converted automatically into value objects
     * or other types, different methods in a class implementing this interface support this feature: look for
     * an <code>int</code> parameter called <code>transform</code>.
     * <p>
     * This specific flag denotes no transformation will occur.
     */
    public static final int TRANSFORM_NONE = 0;


    /**
     * Transforms the given results to a collection of {@link QuantificationMeasurement}
     * instances (this is useful when the returned results contains a row of data and you want just entities only).
     *
     * @param results the query results.
     */
    public void toEntities(final Collection<?> results);

    /**
     * Gets an instance of QuantificationMeasurement from the persistent store.
     * @param id
     * @return QuantificationMeasurement
     */
    public QuantificationMeasurement get(Integer id);

    /**
     * <p>
     * Does the same thing as {@link #get(Integer)} with an
     * additional flag called <code>transform</code>. If this flag is set to <code>TRANSFORM_NONE</code> then
     * the returned entity will <strong>NOT</strong> be transformed. If this flag is any of the other constants
     * defined in this class then the result <strong>WILL BE</strong> passed through an operation which can
     * optionally transform the entity (into a value object for example). By default, transformation does
     * not occur.
     * </p>
     *
     * @param transform flag to determine transformation type.
     * @param id the identifier of the entity to get.
     * @return either the entity or the object transformed from the entity.
     */
    public Object get(int transform, Integer id);

    /**
     * Loads an instance of QuantificationMeasurement from the persistent store.
     * @param id
     * @return QuantificationMeasurement
     */
    public QuantificationMeasurement load(Integer id);

    /**
     * <p>
     * Does the same thing as {@link #load(Integer)} with an
     * additional flag called <code>transform</code>. If this flag is set to <code>TRANSFORM_NONE</code> then
     * the returned entity will <strong>NOT</strong> be transformed. If this flag is any of the other constants
     * defined in this class then the result <strong>WILL BE</strong> passed through an operation which can
     * optionally transform the entity (into a value object for example). By default, transformation does
     * not occur.
     * </p>
     *
     * @param transform flag to determine transformation type.
     * @param id the identifier of the entity to load.
     * @return either the entity or the object transformed from the entity.
     */
    public Object load(int transform, Integer id);

    /**
     * Loads all entities of type {@link QuantificationMeasurement}.
     *
     * @return the loaded entities.
     */
    public Collection<QuantificationMeasurement> loadAll();

    /**
     * <p>
     * Does the same thing as {@link #loadAll()} with an
     * additional flag called <code>transform</code>. If this flag is set to <code>TRANSFORM_NONE</code> then
     * the returned entity will <strong>NOT</strong> be transformed. If this flag is any of the other constants
     * defined here then the result <strong>WILL BE</strong> passed through an operation which can optionally
     * transform the entity (into a value object for example). By default, transformation does
     * not occur.
     * </p>
     *
     * @param transform the flag indicating what transformation to use.
     * @return the loaded entities.
     */
    public Collection<?> loadAll(final int transform);

    /**
     * <p>
     * Does the same thing as {@link #loadAll()} with an
     * additional two arguments called <code>pageNumber</code> and <code>pageSize</code>. The <code>pageNumber</code>
     * argument allows you to specify the page number when you are paging the results and the pageSize allows you to specify the size of the
     * page retrieved.
     * </p>
     *
     * @param pageNumber the page number to retrieve when paging results.
     * @param pageSize the size of the page to retrieve when paging results.
     * @return the loaded entities.
     */
    public Collection<?> loadAll(final int pageNumber, final int pageSize);

    /**
     * <p>
     * Does the same thing as {@link #loadAll(int)} with an
     * additional two arguments called <code>pageNumber</code> and <code>pageSize</code>. The <code>pageNumber</code>
     * argument allows you to specify the page number when you are paging the results and the pageSize allows you to specify the size of the
     * page retrieved.
     * </p>
     *
     * @param transform the flag indicating what transformation to use.
     * @param pageNumber the page number to retrieve when paging results.
     * @param pageSize the size of the page to retrieve when paging results.
     * @return the loaded entities.
     */
    public Collection<?> loadAll(final int transform, final int pageNumber, final int pageSize);

    /**
     * Creates an instance of QuantificationMeasurement and adds it to the persistent store.
     * @param quantificationMeasurement
     * @return QuantificationMeasurement
     */
    public QuantificationMeasurement create(QuantificationMeasurement quantificationMeasurement);

    /**
     * <p>
     * Does the same thing as {@link #create(QuantificationMeasurement)} with an
     * additional flag called <code>transform</code>. If this flag is set to <code>TRANSFORM_NONE</code> then
     * the returned entity will <strong>NOT</strong> be transformed. If this flag is any of the other constants
     * defined here then the result <strong>WILL BE</strong> passed through an operation which can optionally
     * transform the entity (into a value object for example). By default, transformation does
     * not occur.
     * </p>
     * @param transform
     * @param quantificationMeasurement
     * @return Object
     */
    public Object create(int transform, QuantificationMeasurement quantificationMeasurement);

    /**
     * Creates a new instance of QuantificationMeasurement and adds
     * from the passed in <code>entities</code> collection
     *
     * @param entities the collection of QuantificationMeasurement
     * instances to create.
     *
     * @return the created instances.
     */
    public Collection<QuantificationMeasurement> create(Collection<QuantificationMeasurement> entities);

    /**
     * <p>
     * Does the same thing as {@link #create(QuantificationMeasurement)} with an
     * additional flag called <code>transform</code>. If this flag is set to <code>TRANSFORM_NONE</code> then
     * the returned entity will <strong>NOT</strong> be transformed. If this flag is any of the other constants
     * defined here then the result <strong>WILL BE</strong> passed through an operation which can optionally
     * transform the entities (into value objects for example). By default, transformation does
     * not occur.
     * </p>
     * @param transform
     * @param entities
     * @return Collection
     */
    public Collection<?> create(int transform, Collection<QuantificationMeasurement> entities);

    /**
     * <p>
     * Creates a new <code>QuantificationMeasurement</code>
     * instance from <strong>all</strong> attributes and adds it to
     * the persistent store.
     * </p>
     * @param subgroupNumber Numéro du sous ensemble sur lequel porte la mesure de quantification. Si non renseigné, le mesure
porte sur tout le lot rattaché.Une quantification d'un lot peut faire intervenir plusieurs
sous-ensemble sur lequel des mesures sont éffectuées. Par exemple, plusieurs sous-ensembles peuvent
être quantifié par pesée, chaque mesure est donc rattaché à un sous-ensemmble, via le numéro de sous
ensemble.
     * @param isReferenceQuantification S'agit t il de la mesure de référence pour la quantification du lot ? Par défaut, le poids calculé
(par relation taille/poids) est le poids de référence.
Doit etre NULL si subgroupNumber est NULL (un poids de référence ne peut pas porter sur une
sous-ensemble du lot , mais sur tout le lot)
     * @param numericalValue <html>
<head>
<title>V    </title>
</head>
<body>
valeur num&#233;rique de la mesure.<br>Elle est n&#233;cessairement exprim&#233;e
dans l'unit&#233; associ&#233; au PSFM de la mesure.
<br>
Renseign&#233; uniquement pour un PSFM num&#233;rique
(PMFM.parameter.isQualitative=false)
</body>
</html>
     * @param alphanumericalValue <html>
<head>
</head>
<body>
<p>
Valeur alphanum&#233;rique de la mesure.
<br>    </p>
<p>
<br>
<u>Attention :</u> <b>Utilisation &#224; &#233;viter</b>. A utiliser
uniquement dans des cas ou les valeurs qualitatives ne peuvent pas
convenir (format non fixe, etc.).
</p>
<p>
</p>
<p>
Exemples :<br>* Num&#233;ros de contrat (Ventre ERS)<br>* Type de
dimension d'engin (logbook - flux SACAPT) &quot;2X60&quot;, &quot;2x6 dragues 75&quot;,
&quot;13.9x2&quot;, &quot;2x7m&#178;&quot;, &quot;2x17.50&quot;, &quot;2m x 2&quot;, etc
</p>
</body>
</html>
     * @param digitCount <html>
<head>
</head>
<body>
<p>
Nombre de digits saisis dans la valeur num&#233;rique de la mesure.
</p>
<p>
</p>
<p>
Cela permet de stocker &quot;10.00&quot; (numericalvalue=10 et digitCount=2) et de
pouvoir restituer la valeur sous la meme forme.
</p>
</body>
</html>
     * @param precisionValue <html>
<head>
</head>
<body>
<p>
Pr&#233;cision de la mesure. Par exemple : precisioNValue=0.5 pour indiquer
une pr&#233;cision &#224; + ou - &quot;0.5&quot;.
<br>    </p>
<p>
</p>
<p>
Valeur exprim&#233;e soit dans l'unite de la mesure (ex : &quot;mm&quot;), soit en
poucentage de la mesure (suivant la valeur de <i>PrecisionType</i>).
</p>
</body>
</html>
     * @param controlDate Date du controle de la donnée.
Le controle est la première phase de validation de la donnée.
Exemple :
- Dans Allegro, ce controle est effectué lorsque l'utilisateur a achevé sa saisie et qu'il souhaite
"Terminer la saisie", dans le but de transmettre ses données au système centrale. Les controle
effectué par Allegro sur le poste client sont des vérifications sur les champs obligatoires, ou
encore sur la cohérence des données (cas d'un arbre d'échantillonnage).
     * @param validationDate Date de validation de la donnée.
La validation est typiquement effectué par un thématicien responsable des données. Dans Allegro, il
s'agit du superviseur du portefeuille de données qui en est responsable.
     * @param qualificationDate Date de qualification de la donnée.
L'étape de qualification est liée à l'affectation d'un flag qualité (bon, mauvais, etc.) sur la
donnée.
- la qualification n'est pas encore gérée dans Allegro, dans le sens ou il n'existe pass encore
d'interface pour affecter le flag qualité. Par défaut, le niveau de qualité est donc à "non
qualifiée"
     * @param qualificationComments 
     * @return QuantificationMeasurement
     */
    public QuantificationMeasurement create(
        Short subgroupNumber,
        Boolean isReferenceQuantification,
        Float numericalValue,
        String alphanumericalValue,
        Integer digitCount,
        Float precisionValue,
        Date controlDate,
        Date validationDate,
        Date qualificationDate,
        String qualificationComments);

    /**
     * <p>
     * Does the same thing as {@link #create(Short, Boolean, Float, String, Integer, Float, Date, Date, Date, String)} with an
     * additional flag called <code>transform</code>. If this flag is set to <code>TRANSFORM_NONE</code> then
     * the returned entity will <strong>NOT</strong> be transformed. If this flag is any of the other constants
     * defined here then the result <strong>WILL BE</strong> passed through an operation which can optionally
     * transform the entity (into a value object for example). By default, transformation does
     * not occur.
     * </p>
     * @param transform
     * @param subgroupNumber Numéro du sous ensemble sur lequel porte la mesure de quantification. Si non renseigné, le mesure
porte sur tout le lot rattaché.Une quantification d'un lot peut faire intervenir plusieurs
sous-ensemble sur lequel des mesures sont éffectuées. Par exemple, plusieurs sous-ensembles peuvent
être quantifié par pesée, chaque mesure est donc rattaché à un sous-ensemmble, via le numéro de sous
ensemble.
     * @param isReferenceQuantification S'agit t il de la mesure de référence pour la quantification du lot ? Par défaut, le poids calculé
(par relation taille/poids) est le poids de référence.
Doit etre NULL si subgroupNumber est NULL (un poids de référence ne peut pas porter sur une
sous-ensemble du lot , mais sur tout le lot)
     * @param numericalValue <html>
<head>
<title>V    </title>
</head>
<body>
valeur num&#233;rique de la mesure.<br>Elle est n&#233;cessairement exprim&#233;e
dans l'unit&#233; associ&#233; au PSFM de la mesure.
<br>
Renseign&#233; uniquement pour un PSFM num&#233;rique
(PMFM.parameter.isQualitative=false)
</body>
</html>
     * @param alphanumericalValue <html>
<head>
</head>
<body>
<p>
Valeur alphanum&#233;rique de la mesure.
<br>    </p>
<p>
<br>
<u>Attention :</u> <b>Utilisation &#224; &#233;viter</b>. A utiliser
uniquement dans des cas ou les valeurs qualitatives ne peuvent pas
convenir (format non fixe, etc.).
</p>
<p>
</p>
<p>
Exemples :<br>* Num&#233;ros de contrat (Ventre ERS)<br>* Type de
dimension d'engin (logbook - flux SACAPT) &quot;2X60&quot;, &quot;2x6 dragues 75&quot;,
&quot;13.9x2&quot;, &quot;2x7m&#178;&quot;, &quot;2x17.50&quot;, &quot;2m x 2&quot;, etc
</p>
</body>
</html>
     * @param digitCount <html>
<head>
</head>
<body>
<p>
Nombre de digits saisis dans la valeur num&#233;rique de la mesure.
</p>
<p>
</p>
<p>
Cela permet de stocker &quot;10.00&quot; (numericalvalue=10 et digitCount=2) et de
pouvoir restituer la valeur sous la meme forme.
</p>
</body>
</html>
     * @param precisionValue <html>
<head>
</head>
<body>
<p>
Pr&#233;cision de la mesure. Par exemple : precisioNValue=0.5 pour indiquer
une pr&#233;cision &#224; + ou - &quot;0.5&quot;.
<br>    </p>
<p>
</p>
<p>
Valeur exprim&#233;e soit dans l'unite de la mesure (ex : &quot;mm&quot;), soit en
poucentage de la mesure (suivant la valeur de <i>PrecisionType</i>).
</p>
</body>
</html>
     * @param controlDate Date du controle de la donnée.
Le controle est la première phase de validation de la donnée.
Exemple :
- Dans Allegro, ce controle est effectué lorsque l'utilisateur a achevé sa saisie et qu'il souhaite
"Terminer la saisie", dans le but de transmettre ses données au système centrale. Les controle
effectué par Allegro sur le poste client sont des vérifications sur les champs obligatoires, ou
encore sur la cohérence des données (cas d'un arbre d'échantillonnage).
     * @param validationDate Date de validation de la donnée.
La validation est typiquement effectué par un thématicien responsable des données. Dans Allegro, il
s'agit du superviseur du portefeuille de données qui en est responsable.
     * @param qualificationDate Date de qualification de la donnée.
L'étape de qualification est liée à l'affectation d'un flag qualité (bon, mauvais, etc.) sur la
donnée.
- la qualification n'est pas encore gérée dans Allegro, dans le sens ou il n'existe pass encore
d'interface pour affecter le flag qualité. Par défaut, le niveau de qualité est donc à "non
qualifiée"
     * @param qualificationComments 
     * @return QuantificationMeasurement
     */
    public Object create(
        int transform,
        Short subgroupNumber,
        Boolean isReferenceQuantification,
        Float numericalValue,
        String alphanumericalValue,
        Integer digitCount,
        Float precisionValue,
        Date controlDate,
        Date validationDate,
        Date qualificationDate,
        String qualificationComments);

    /**
     * <p>
     * Creates a new <code>QuantificationMeasurement</code>
     * instance from only <strong>required</strong> properties (attributes
     * and association ends) and adds it to the persistent store.
     * </p>
     * @param pmfm
     * @param qualityFlag
     * @param batch
     * @return QuantificationMeasurement
     */
    public QuantificationMeasurement create(
        Pmfm pmfm,
        QualityFlag qualityFlag,
        Batch batch);

    /**
     * <p>
     * Does the same thing as {@link #create()} with an
     * additional flag called <code>transform</code>. If this flag is set to <code>TRANSFORM_NONE</code> then
     * the returned entity will <strong>NOT</strong> be transformed. If this flag is any of the other constants
     * defined here then the result <strong>WILL BE</strong> passed through an operation which can optionally
     * transform the entity (into a value object for example). By default, transformation does
     * not occur.
     * </p>
     * @param transform flag to determine transformation type.
     * @param pmfm
     * @param qualityFlag
     * @param batch
     * @return Object
     */
    public Object create(
        int transform,
        Pmfm pmfm,
        QualityFlag qualityFlag,
        Batch batch);

    /**
     * Updates the <code>quantificationMeasurement</code> instance in the persistent store.
     * @param quantificationMeasurement
     */
    public void update(QuantificationMeasurement quantificationMeasurement);

    /**
     * Updates all instances in the <code>entities</code> collection in the persistent store.
     * @param entities
     */
    public void update(Collection<QuantificationMeasurement> entities);

    /**
     * Removes the instance of QuantificationMeasurement from the persistent store.
     * @param quantificationMeasurement
     */
    public void remove(QuantificationMeasurement quantificationMeasurement);

    /**
     * Removes the instance of QuantificationMeasurement having the given
     * <code>identifier</code> from the persistent store.
     * @param id
     */
    public void remove(Integer id);

    /**
     * Removes all entities in the given <code>entities</code> collection.
     * @param entities
     */
    public void remove(Collection<QuantificationMeasurement> entities);


    /**
     * Does the same thing as {@link #search(int, Search)} but with an
     * additional two flags called <code>pageNumber</code> and <code>pageSize</code>. These flags allow you to
     * limit your data to a specified page number and size.
     *
     * @param transform the transformation flag.
     * @param pageNumber the page number in the data to retrieve
     * @param pageSize the size of the page to retrieve.
     * @param search the search object which provides the search parameters and pagination specification.
     * @return any found results from the search wrapped in a {@link PaginationResult} instance.
     */
    public PaginationResult search(final int transform, final int pageNumber, final int pageSize, final Search search);

    /**
     * Does the same thing as {@link #search(Search)} but with an
     * additional two flags called <code>pageNumber</code> and <code>pageSize</code>. These flags allow you to
     * limit your data to a specified page number and size.
     *
     * @param pageNumber the page number in the data to retrieve
     * @param pageSize the size of the page to retrieve.
     * @param search the search object which provides the search parameters and pagination specification.
     * @return any found results from the search wrapped in a {@link PaginationResult} instance.
     */
    public PaginationResult search(final int pageNumber, final int pageSize, final Search search);

    /**
     * Does the same thing as {@link #search(Search)} but with an
     * additional flag called <code>transform</code>. If this flag is set to <code>TRANSFORM_NONE</code> then
     * finder results will <strong>NOT</strong> be transformed during retrieval.
     * If this flag is any of the other constants defined here
     * then results <strong>WILL BE</strong> passed through an operation which can optionally
     * transform the entities (into value objects for example). By default, transformation does
     * not occur.
     *
     * @param transform the transformation flag.
     * @param search the search object which provides the search parameters and pagination specification.
     * @return any found results from the search.
     */
    public Set<?> search(final int transform, final Search search);

    /**
     * Performs a search using the parameters specified in the given <code>search</code> object.
     *
     * @param search the search object which provides the search parameters and pagination specification.
     * @return any found results from the search.
     */
    public Set<QuantificationMeasurement> search(final Search search);

    /**
     * Allows transformation of entities into value objects
     * (or something else for that matter), when the <code>transform</code>
     * flag is set to one of the constants defined in <code>fr.ifremer.adagio.core.dao.data.measure.QuantificationMeasurementDao</code>, please note
     * that the {@link #TRANSFORM_NONE} constant denotes no transformation, so the entity itself
     * will be returned.
     *
     * If the integer argument value is unknown {@link #TRANSFORM_NONE} is assumed.
     *
     * @param transform one of the constants declared in {@link fr.ifremer.adagio.core.dao.data.measure.QuantificationMeasurementDao}
     * @param entity an entity that was found
     * @return the transformed entity (i.e. new value object, etc)
     * @see #transformEntities(int,Collection)
     */
    public Object transformEntity(final int transform, final QuantificationMeasurement entity);

    /**
     * Transforms a collection of entities using the
     * {@link #transformEntity(int,QuantificationMeasurement)}
     * method. This method does not instantiate a new collection.
     * <p>
     * This method is to be used internally only.
     *
     * @param transform one of the constants declared in <code>fr.ifremer.adagio.core.dao.data.measure.QuantificationMeasurementDao</code>
     * @param entities the collection of entities to transform
     * @see #transformEntity(int,QuantificationMeasurement)
     */
    public void transformEntities(final int transform, final Collection<?> entities);

    // spring-dao merge-point
}