/* @source ensdensity *********************************************************
**
** Ensembl Density functions
**
** @author Copyright (C) 1999 Ensembl Developers
** @author Copyright (C) 2006 Michael K. Schuster
** @version $Revision: 1.66 $
** @modified 2009 by Alan Bleasby for incorporation into EMBOSS core
** @modified $Date: 2013/02/17 13:02:10 $ by $Author: mks $
** @@
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library 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
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
** MA  02110-1301,  USA.
**
******************************************************************************/

/* ========================================================================= */
/* ============================= include files ============================= */
/* ========================================================================= */

#include "ensdensity.h"
#include "enstable.h"
#include <math.h>




/* ========================================================================= */
/* =============================== constants =============================== */
/* ========================================================================= */




/* ========================================================================= */
/* =========================== global variables ============================ */
/* ========================================================================= */




/* ========================================================================= */
/* ============================= private data ============================== */
/* ========================================================================= */

/* @datastatic DensityPTypeRatio **********************************************
**
** Ensembl Density Type Ratio.
**
** Holds Ensembl Density Types and corresponding ratios.
**
** @alias DensitySTypeRatio
** @alias DensityOTypeRatio
**
** @attr Densitytype [EnsPDensitytype] Ensembl Density Type
** @attr Ratio [float] Ratio
** @attr Padding [ajuint] Padding to alignment boundary
** @@
******************************************************************************/

typedef struct DensitySTypeRatio
{
    EnsPDensitytype Densitytype;
    float Ratio;
    ajuint Padding;
} DensityOTypeRatio;

#define DensityPTypeRatio DensityOTypeRatio*




/* @datastatic DensityPLengthValue ********************************************
**
** Ensembl Density Length Value.
**
** Holds density values and corresponding lengths.
**
** @alias DensitySLengthValue
** @alias DensityOLengthValue
**
** @attr Length [ajuint] Length
** @attr Value [float] Value
** @@
******************************************************************************/

typedef struct DensitySLengthValue
{
    ajuint Length;
    float Value;
} DensityOLengthValue;

#define DensityPLengthValue DensityOLengthValue*




/* ========================================================================= */
/* =========================== private constants =========================== */
/* ========================================================================= */

/* @conststatic densitytypeKType **********************************************
**
** The Density Type type is enumerated in both, the SQL table definition
** and the data structure. The following strings are used for
** conversion in database operations and correspond to
** EnsEDensitytypeType.
**
** sum:
** ratio:
**
******************************************************************************/

static const char *const densitytypeKType[] =
{
    "",
    "sum",
    "ratio",
    (const char *) NULL
};




/* @conststatic densitytypeadaptorKTablenames *********************************
**
** Ensembl Density Type Adaptor SQL table names
**
******************************************************************************/

static const char *const densitytypeadaptorKTablenames[] =
{
    "density_type",
    (const char *) NULL
};




/* @conststatic densitytypeadaptorKColumnnames ********************************
**
** Ensembl Density Type Adaptor SQL column names
**
******************************************************************************/

static const char *const densitytypeadaptorKColumnnames[] =
{
    "density_type.density_type_id",
    "density_type.analysis_id",
    "density_type.value_type",
    "density_type.block_size",
    "density_type.region_features",
    (const char *) NULL
};




/* @conststatic densityfeatureadaptorKTablenames ******************************
**
** Ensembl Density Feature Adaptor SQL table names
**
******************************************************************************/

static const char *const densityfeatureadaptorKTablenames[] =
{
    "density_feature",
    (const char *) NULL
};




/* @conststatic densityfeatureadaptorKColumnnames *****************************
**
** Ensembl Density Feature Adaptor SQL column names
**
******************************************************************************/

static const char *const densityfeatureadaptorKColumnnames[] =
{
    "density_feature.density_feature_id",
    "density_feature.seq_region_id",
    "density_feature.seq_region_start",
    "density_feature.seq_region_end",
    "density_feature.density_type_id",
    "density_feature.density_value",
    (const char *) NULL
};




/* ========================================================================= */
/* =========================== private variables =========================== */
/* ========================================================================= */




/* ========================================================================= */
/* =========================== private functions =========================== */
/* ========================================================================= */

static int listDensitytyperatioCompareRatioAscending(
    const void *item1,
    const void *item2);

static int listDensityfeatureCompareEndAscending(
    const void *item1,
    const void *item2);

static int listDensityfeatureCompareEndDescending(
    const void *item1,
    const void *item2);

static int listDensityfeatureCompareIdentifierAscending(
    const void *item1,
    const void *item2);

static int listDensityfeatureCompareStartAscending(
    const void *item1,
    const void *item2);

static int listDensityfeatureCompareStartDescending(
    const void *item1,
    const void *item2);

static AjBool densitytypeadaptorFetchAllbyStatement(
    EnsPBaseadaptor ba,
    const AjPStr statement,
    EnsPAssemblymapper am,
    EnsPSlice slice,
    AjPList dts);

static AjBool densitytypeadaptorCacheInsert(EnsPDensitytypeadaptor dta,
                                            EnsPDensitytype *Pdt);

static AjBool densitytypeadaptorCacheInit(EnsPDensitytypeadaptor dta);

static void densitytypeadaptorFetchAll(const void *key,
                                       void **Pvalue,
                                       void *cl);

static AjBool densityfeatureadaptorFetchAllbyStatement(
    EnsPBaseadaptor ba,
    const AjPStr statement,
    EnsPAssemblymapper am,
    EnsPSlice slice,
    AjPList dfs);




/* @funcstatic listDensitytyperatioCompareRatioAscending **********************
**
** Comparison function to sort Density Type Ratios by their ratio
** in ascending order.
**
** @param [r] item1 [const void*] Density Type Ratio address 1
** @param [r] item2 [const void*] Density Type Ratio address 2
** @see ajListSort
**
** @return [int] The comparison function returns an integer less than,
**               equal to, or greater than zero if the first argument is
**               considered to be respectively less than, equal to, or
**               greater than the second.
**
** @release 6.3.0
** @@
******************************************************************************/

static int listDensitytyperatioCompareRatioAscending(
    const void *item1,
    const void *item2)
{
    int result = 0;

    DensityPTypeRatio dtr1 = *(DensityOTypeRatio *const *) item1;
    DensityPTypeRatio dtr2 = *(DensityOTypeRatio *const *) item2;

#if defined(AJ_DEBUG) && AJ_DEBUG >= 2
    if (ajDebugTest("listDensitytyperatioCompareRatioAscending"))
        ajDebug("listDensitytyperatioCompareRatioAscending\n"
                "  dtr1 %p\n"
                "  dtr2 %p\n",
                dtr1,
                dtr2);
#endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 2 */

    /* Sort empty values towards the end of the AJAX List. */

    if (dtr1 && (!dtr2))
        return -1;

    if ((!dtr1) && (!dtr2))
        return 0;

    if ((!dtr1) && dtr2)
        return +1;

    /* Evaluate Density Type ratios. */

    if (dtr1->Ratio < dtr2->Ratio)
        result = -1;

    if (dtr1->Ratio > dtr2->Ratio)
        result = +1;

    return result;
}




/* ========================================================================= */
/* ======================= All functions by section ======================== */
/* ========================================================================= */




/* @filesection ensdensity ****************************************************
**
** @nam1rule ens Function belongs to the Ensembl library
**
******************************************************************************/




/* @datasection [EnsPDensitytype] Ensembl Density Type ************************
**
** @nam2rule Densitytype Functions for manipulating
** Ensembl Density Type objects.
**
** @cc Bio::EnsEMBL::DensityType
** @cc CVS Revision: 1.10
** @cc CVS Tag: branch-ensembl-68
**
******************************************************************************/




/* @section constructors ******************************************************
**
** All constructors return a new Ensembl Density Type by pointer.
** It is the responsibility of the user to first destroy any previous
** Density Type. The target pointer does not need to be initialised to
** NULL, but it is good programming practice to do so anyway.
**
** @fdata [EnsPDensitytype]
**
** @nam3rule New Constructor
** @nam4rule Cpy Constructor with existing object
** @nam4rule Ini Constructor with initial values
** @nam4rule Ref Constructor by incrementing the reference counter
**
** @argrule Cpy dt [const EnsPDensitytype] Ensembl Density Type
** @argrule Ini dta [EnsPDensitytypeadaptor] Ensembl Density Type Adaptor
** @argrule Ini identifier [ajuint] SQL database-internal identifier
** @argrule Ini analysis [EnsPAnalysis] Ensembl Analysis
** @argrule Ini type [EnsEDensitytypeType] Type
** @argrule Ini size [ajuint] Block size
** @argrule Ini features [ajuint]
** Number of Ensembl Density Feature objects per Ensembl Sequence Region
** @argrule Ref dt [EnsPDensitytype] Ensembl Density Type
**
** @valrule * [EnsPDensitytype] Ensembl Density Type or NULL
**
** @fcategory new
******************************************************************************/




/* @func ensDensitytypeNewCpy *************************************************
**
** Object-based constructor function, which returns an independent object.
**
** @param [r] dt [const EnsPDensitytype] Ensembl Density Type
**
** @return [EnsPDensitytype] Ensembl Density Type or NULL
**
** @release 6.4.0
** @@
******************************************************************************/

EnsPDensitytype ensDensitytypeNewCpy(const EnsPDensitytype dt)
{
    EnsPDensitytype pthis = NULL;

    if (!dt)
        return NULL;

    AJNEW0(pthis);

    pthis->Use        = 1U;
    pthis->Identifier = dt->Identifier;
    pthis->Adaptor    = dt->Adaptor;
    pthis->Analysis   = ensAnalysisNewRef(dt->Analysis);
    pthis->Type       = dt->Type;
    pthis->Size       = dt->Size;
    pthis->Features   = dt->Features;

    return pthis;
}




/* @func ensDensitytypeNewIni *************************************************
**
** Constructor for an Ensembl Density Type with initial values.
**
** @cc Bio::EnsEMBL::Storable::new
** @param [u] dta [EnsPDensitytypeadaptor] Ensembl Density Type Adaptor
** @param [r] identifier [ajuint] SQL database-internal identifier
** @cc Bio::EnsEMBL::DensityType::new
** @param [u] analysis [EnsPAnalysis] Ensembl Analysis
** @param [u] type [EnsEDensitytypeType] Type
** @param [r] size [ajuint] Block size
** @param [r] features [ajuint]
** Number of Ensembl Density Feature objects per Ensembl Sequence Region
**
** @return [EnsPDensitytype] Ensembl Density Type or NULL
**
** @release 6.4.0
** @@
******************************************************************************/

EnsPDensitytype ensDensitytypeNewIni(EnsPDensitytypeadaptor dta,
                                     ajuint identifier,
                                     EnsPAnalysis analysis,
                                     EnsEDensitytypeType type,
                                     ajuint size,
                                     ajuint features)
{
    EnsPDensitytype dt = NULL;

    if (!analysis)
        return NULL;

    AJNEW0(dt);

    dt->Use        = 1U;
    dt->Identifier = identifier;
    dt->Adaptor    = dta;
    dt->Analysis   = ensAnalysisNewRef(analysis);
    dt->Type       = type;
    dt->Size       = size;
    dt->Features   = features;

    return dt;
}




/* @func ensDensitytypeNewRef *************************************************
**
** Ensembl Object referencing function, which returns a pointer to the
** Ensembl Object passed in and increases its reference count.
**
** @param [u] dt [EnsPDensitytype] Ensembl Density Type
**
** @return [EnsPDensitytype] Ensembl Density Type or NULL
**
** @release 6.2.0
** @@
******************************************************************************/

EnsPDensitytype ensDensitytypeNewRef(EnsPDensitytype dt)
{
    if (!dt)
        return NULL;

    dt->Use++;

    return dt;
}




/* @section destructors *******************************************************
**
** Destruction destroys all internal data structures and frees the memory
** allocated for an Ensembl Density Type object.
**
** @fdata [EnsPDensitytype]
**
** @nam3rule Del Destroy (free) an Ensembl Density Type
**
** @argrule * Pdt [EnsPDensitytype*] Ensembl Density Type address
**
** @valrule * [void]
**
** @fcategory delete
******************************************************************************/




/* @func ensDensitytypeDel ****************************************************
**
** Default destructor for an Ensembl Density Type.
**
** @param [d] Pdt [EnsPDensitytype*] Ensembl Density Type address
**
** @return [void]
**
** @release 6.2.0
** @@
******************************************************************************/

void ensDensitytypeDel(EnsPDensitytype *Pdt)
{
    EnsPDensitytype pthis = NULL;

    if (!Pdt)
        return;

#if defined(AJ_DEBUG) && AJ_DEBUG >= 1
    if (ajDebugTest("ensDensitytypeDel"))
    {
        ajDebug("ensDensitytypeDel\n"
                "  *Pdt %p\n",
                *Pdt);

        ensDensitytypeTrace(*Pdt, 1);
    }
#endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */

    if (!(pthis = *Pdt) || --pthis->Use)
    {
        *Pdt = NULL;

        return;
    }

    ensAnalysisDel(&pthis->Analysis);

    ajMemFree((void **) Pdt);

    return;
}




/* @section member retrieval **************************************************
**
** Functions for returning members of an Ensembl Density Type object.
**
** @fdata [EnsPDensitytype]
**
** @nam3rule Get Return Density Type attribute(s)
** @nam4rule Adaptor Return the Ensembl Density Type Adaptor
** @nam4rule Analysis Return the Ensembl Analysis
** @nam4rule Features Return the number of Ensembl Density Feature objects
** @nam4rule Identifier Return the SQL database-internal identifier
** @nam4rule Size Return the block size
** @nam4rule Type Return the type
**
** @argrule * dt [const EnsPDensitytype] Density Type
**
** @valrule Adaptor [EnsPDensitytypeadaptor] Ensembl Density Type Adaptor
** or NULL
** @valrule Analysis [EnsPAnalysis] Ensembl Analysis or NULL
** @valrule Features [ajuint] Number of Ensembl Density Feature objects or 0U
** @valrule Identifier [ajuint] SQL database-internal identifier or 0U
** @valrule Size [ajuint] Block size or 0U
** @valrule Type [EnsEDensitytypeType] Type or ensEDensitytypeTypeNULL
**
** @fcategory use
******************************************************************************/




/* @func ensDensitytypeGetAdaptor *********************************************
**
** Get the Ensembl Density Type Adaptor member of an Ensembl Density Type.
**
** @cc Bio::EnsEMBL::Storable::adaptor
** @param [r] dt [const EnsPDensitytype] Ensembl Density Type
**
** @return [EnsPDensitytypeadaptor] Ensembl Density Type Adaptor or NULL
**
** @release 6.2.0
** @@
******************************************************************************/

EnsPDensitytypeadaptor ensDensitytypeGetAdaptor(const EnsPDensitytype dt)
{
    return (dt) ? dt->Adaptor : NULL;
}




/* @func ensDensitytypeGetAnalysis ********************************************
**
** Get the Ensembl Analysis member of an Ensembl Density Type.
**
** @cc Bio::EnsEMBL::DensityType::analysis
** @param [r] dt [const EnsPDensitytype] Ensembl Density Type
**
** @return [EnsPAnalysis] Ensembl Analysis or NULL
**
** @release 6.2.0
** @@
******************************************************************************/

EnsPAnalysis ensDensitytypeGetAnalysis(const EnsPDensitytype dt)
{
    return (dt) ? dt->Analysis : NULL;
}




/* @func ensDensitytypeGetFeatures ********************************************
**
** Get the number of Ensembl Density Feature objects member of an
** Ensembl Density Type.
**
** @cc Bio::EnsEMBL::DensityType::region_features
** @param [r] dt [const EnsPDensitytype] Ensembl Density Type
**
** @return [ajuint] Number of Ensembl Density Feature objects or 0U
**
** @release 6.4.0
** @@
******************************************************************************/

ajuint ensDensitytypeGetFeatures(const EnsPDensitytype dt)
{
    return (dt) ? dt->Features : 0U;
}




/* @func ensDensitytypeGetIdentifier ******************************************
**
** Get the SQL database-internal identifier member of an
** Ensembl Density Type.
**
** @cc Bio::EnsEMBL::Storable::dbID
** @param [r] dt [const EnsPDensitytype] Ensembl Density Type
**
** @return [ajuint] SQL database-internal identifier or 0U
**
** @release 6.2.0
** @@
******************************************************************************/

ajuint ensDensitytypeGetIdentifier(const EnsPDensitytype dt)
{
    return (dt) ? dt->Identifier : 0U;
}




/* @func ensDensitytypeGetSize ************************************************
**
** Get the block size member of an Ensembl Density Type.
**
** @cc Bio::EnsEMBL::DensityType::block_size
** @param [r] dt [const EnsPDensitytype] Ensembl Density Type
**
** @return [ajuint] Block size or 0U
**
** @release 6.4.0
** @@
******************************************************************************/

ajuint ensDensitytypeGetSize(const EnsPDensitytype dt)
{
    return (dt) ? dt->Size : 0U;
}




/* @func ensDensitytypeGetType ************************************************
**
** Get the type member of an Ensembl Density Type.
**
** @cc Bio::EnsEMBL::DensityType::value_type
** @param [r] dt [const EnsPDensitytype] Ensembl Density Type
**
** @return [EnsEDensitytypeType] Type or ensEDensitytypeTypeNULL
**
** @release 6.4.0
** @@
******************************************************************************/

EnsEDensitytypeType ensDensitytypeGetType(const EnsPDensitytype dt)
{
    return (dt) ? dt->Type : ensEDensitytypeTypeNULL;
}




/* @section member assignment *************************************************
**
** Functions for assigning members of an Ensembl Density Type object.
**
** @fdata [EnsPDensitytype]
**
** @nam3rule Set Set one member of a Density Type
** @nam4rule Adaptor Set the Ensembl Density Type Adaptor
** @nam4rule Analysis Set the Ensembl Analysis
** @nam4rule Features Set the number of Ensembl Density Feature objects
** @nam4rule Identifier Set the SQL database-internal identifier
** @nam4rule Size Set the block size
** @nam4rule Type Set the type
**
** @argrule * dt [EnsPDensitytype] Ensembl Density Feature object
** @argrule Adaptor dta [EnsPDensitytypeadaptor] Ensembl Density Type Adaptor
** @argrule Analysis analysis [EnsPAnalysis] Ensembl Analysis
** @argrule Features features [ajuint]
** Number of Ensembl Density Feature objects
** @argrule Identifier identifier [ajuint] SQL database-internal identifier
** @argrule Size size [ajuint] Block size
** @argrule Type type [EnsEDensitytypeType] Type
**
** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
**
** @fcategory modify
******************************************************************************/




/* @func ensDensitytypeSetAdaptor *********************************************
**
** Set the Ensembl Density Type Adaptor member of an Ensembl Density Type.
**
** @cc Bio::EnsEMBL::Storable::adaptor
** @param [u] dt [EnsPDensitytype] Ensembl Density Type
** @param [u] dta [EnsPDensitytypeadaptor] Ensembl Density Type Adaptor
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.2.0
** @@
******************************************************************************/

AjBool ensDensitytypeSetAdaptor(EnsPDensitytype dt,
                                EnsPDensitytypeadaptor dta)
{
    if (!dt)
        return ajFalse;

    dt->Adaptor = dta;

    return ajTrue;
}




/* @func ensDensitytypeSetAnalysis ********************************************
**
** Set the Ensembl Analysis member of an Ensembl Density Type.
**
** @cc Bio::EnsEMBL::DensityType::analysis
** @param [u] dt [EnsPDensitytype] Ensembl Density Type
** @param [u] analysis [EnsPAnalysis] Ensembl Analysis
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.2.0
** @@
******************************************************************************/

AjBool ensDensitytypeSetAnalysis(EnsPDensitytype dt,
                                 EnsPAnalysis analysis)
{
    if (!dt)
        return ajFalse;

    ensAnalysisDel(&dt->Analysis);

    dt->Analysis = ensAnalysisNewRef(analysis);

    return ajTrue;
}




/* @func ensDensitytypeSetFeatures ********************************************
**
** Set the number of Ensembl Density Feature objects member of an
** Ensembl Density Type.
**
** @cc Bio::EnsEMBL::DensityType::region_features
** @param [u] dt [EnsPDensitytype] Ensembl Density Type
** @param [r] features [ajuint] Number of Ensembl Density Feature objects
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.4.0
** @@
******************************************************************************/

AjBool ensDensitytypeSetFeatures(EnsPDensitytype dt,
                                 ajuint features)
{
    if (!dt)
        return ajFalse;

    dt->Features = features;

    return ajTrue;
}




/* @func ensDensitytypeSetIdentifier ******************************************
**
** Set the SQL database-internal identifier member of an
** Ensembl Density Type.
**
** @cc Bio::EnsEMBL::Storable::dbID
** @param [u] dt [EnsPDensitytype] Ensembl Density Type
** @param [r] identifier [ajuint] SQL database-internal identifier
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.2.0
** @@
******************************************************************************/

AjBool ensDensitytypeSetIdentifier(EnsPDensitytype dt,
                                   ajuint identifier)
{
    if (!dt)
        return ajFalse;

    dt->Identifier = identifier;

    return ajTrue;
}




/* @func ensDensitytypeSetSize ************************************************
**
** Set the block size member of an Ensembl Density Type.
**
** @cc Bio::EnsEMBL::DensityType::block_size
** @param [u] dt [EnsPDensitytype] Ensembl Density Type
** @param [r] size [ajuint] Block size
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.4.0
** @@
******************************************************************************/

AjBool ensDensitytypeSetSize(EnsPDensitytype dt,
                             ajuint size)
{
    if (!dt)
        return ajFalse;

    dt->Size = size;

    return ajTrue;
}




/* @func ensDensitytypeSetType ************************************************
**
** Set the type member of an Ensembl Density Type.
**
** @cc Bio::EnsEMBL::DensityType::value_type
** @param [u] dt [EnsPDensitytype] Ensembl Density Type
** @param [u] type [EnsEDensitytypeType] Type
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.4.0
** @@
******************************************************************************/

AjBool ensDensitytypeSetType(EnsPDensitytype dt,
                             EnsEDensitytypeType type)
{
    if (!dt)
        return ajFalse;

    dt->Type = type;

    return ajTrue;
}




/* @section debugging *********************************************************
**
** Functions for reporting of an Ensembl Density Type object.
**
** @fdata [EnsPDensitytype]
**
** @nam3rule Trace Report Ensembl Density Type members to debug file
**
** @argrule Trace dt [const EnsPDensitytype] Ensembl Density Type
** @argrule Trace level [ajuint] Indentation level
**
** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
**
** @fcategory misc
******************************************************************************/




/* @func ensDensitytypeTrace **************************************************
**
** Trace an Ensembl Density Type.
**
** @param [r] dt [const EnsPDensitytype] Ensembl Density Type
** @param [r] level [ajuint] Indentation level
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.2.0
** @@
******************************************************************************/

AjBool ensDensitytypeTrace(const EnsPDensitytype dt, ajuint level)
{
    AjPStr indent = NULL;

    if (!dt)
        return ajFalse;

    indent = ajStrNew();

    ajStrAppendCountK(&indent, ' ', level * 2);

    ajDebug("%SensDensitytypeTrace %p\n"
            "%S  Use %u\n"
            "%S  Identifier %u\n"
            "%S  Adaptor %p\n"
            "%S  Analysis %p\n"
            "%S  Type '%s'\n"
            "%S  Size %u\n"
            "%S  Features %u\n",
            indent, dt,
            indent, dt->Use,
            indent, dt->Identifier,
            indent, dt->Adaptor,
            indent, dt->Analysis,
            indent, ensDensitytypeTypeToChar(dt->Type),
            indent, dt->Size,
            indent, dt->Features);

    ensAnalysisTrace(dt->Analysis, level + 1);

    ajStrDel(&indent);

    return ajTrue;
}




/* @section calculate *********************************************************
**
** Functions for calculating information from an Ensembl Density Type object.
**
** @fdata [EnsPDensitytype]
**
** @nam3rule Calculate Calculate Ensembl Density Type information
** @nam4rule Memsize Calculate the memory size in bytes
**
** @argrule * dt [const EnsPDensitytype] Ensembl Density Type
**
** @valrule Memsize [size_t] Memory size in bytes or 0
**
** @fcategory misc
******************************************************************************/




/* @func ensDensitytypeCalculateMemsize ***************************************
**
** Calculate the memory size in bytes of an Ensembl Density Type.
**
** @param [r] dt [const EnsPDensitytype] Ensembl Density Type
**
** @return [size_t] Memory size in bytes or 0
**
** @release 6.4.0
** @@
******************************************************************************/

size_t ensDensitytypeCalculateMemsize(const EnsPDensitytype dt)
{
    size_t size = 0;

    if (!dt)
        return 0;

    size += sizeof (EnsODensitytype);

    size += ensAnalysisCalculateMemsize(dt->Analysis);

    return size;
}




/* @datasection [EnsEDensitytypeType] Ensembl Density Type Type ***************
**
** @nam2rule Densitytype Functions for manipulating
** Ensembl Density Type objects
** @nam3rule DensitytypeType Functions for manipulating
** Ensembl Density Type Type enumerations
**
******************************************************************************/




/* @section Misc **************************************************************
**
** Functions for returning an Ensembl Density Type Type enumeration.
**
** @fdata [EnsEDensitytypeType]
**
** @nam4rule From Ensembl Density Type Type query
** @nam5rule Str  AJAX String object query
**
** @argrule  Str  type [const AjPStr] Type string
**
** @valrule * [EnsEDensitytypeType] Ensembl Density Type Type or
**                                  ensEDensitytypeTypeNULL
**
** @fcategory misc
******************************************************************************/




/* @func ensDensitytypeTypeFromStr ********************************************
**
** Convert an AJAX String into an Ensembl Density Type Type enumeration.
**
** @param [r] type [const AjPStr] Type string
**
** @return [EnsEDensitytypeType] Ensembl Density Type Type or
**                                    ensEDensitytypeTypeNULL
**
** @release 6.4.0
** @@
******************************************************************************/

EnsEDensitytypeType ensDensitytypeTypeFromStr(const AjPStr type)
{
    register EnsEDensitytypeType i = ensEDensitytypeTypeNULL;

    EnsEDensitytypeType etype = ensEDensitytypeTypeNULL;

    for (i = ensEDensitytypeTypeNULL;
         densitytypeKType[i];
         i++)
        if (ajStrMatchC(type, densitytypeKType[i]))
            etype = i;

    if (!etype)
        ajDebug("ensDensitytypeTypeFromStr encountered "
                "unexpected string '%S'.\n", type);

    return etype;
}




/* @section Cast **************************************************************
**
** Functions for returning attributes of an
** Ensembl Density Type Type enumeration.
**
** @fdata [EnsEDensitytypeType]
**
** @nam4rule To   Return Ensembl Density Type Type enumeration
** @nam5rule Char Return C character string value
**
** @argrule To dtt [EnsEDensitytypeType] Ensembl Density Type Type enumeration
**
** @valrule Char [const char*] Ensembl Density Type type C-type (char *) string
**
** @fcategory cast
******************************************************************************/




/* @func ensDensitytypeTypeToChar *********************************************
**
** Convert an Ensembl Density Type Type enumeration
** into a C-type (char *) string.
**
** @param [u] dtt [EnsEDensitytypeType] Ensembl Density Type Type enumeration
**
** @return [const char*] Ensembl Density Type type C-type (char *) string
**
** @release 6.4.0
** @@
******************************************************************************/

const char* ensDensitytypeTypeToChar(EnsEDensitytypeType dtt)
{
    register EnsEDensitytypeType i = ensEDensitytypeTypeNULL;

    for (i = ensEDensitytypeTypeNULL;
         densitytypeKType[i] && (i < dtt);
         i++);

    if (!densitytypeKType[i])
        ajDebug("ensDensitytypeTypeToChar "
                "encountered an out of boundary error on "
                "Ensembl Density Type Type "
                "enumeration %d.\n",
                dtt);

    return densitytypeKType[i];
}




/* @datasection [EnsPDensitytypeadaptor] Ensembl Density Type Adaptor *********
**
** @nam2rule Densitytypeadaptor Functions for manipulating
** Ensembl Density Type Adaptor objects
**
** @cc Bio::EnsEMBL::DBSQL::DensityTypeAdaptor
** @cc CVS Revision: 1.16
** @cc CVS Tag: branch-ensembl-68
**
******************************************************************************/




/* @funcstatic densitytypeadaptorFetchAllbyStatement **************************
**
** Run a SQL statement against an Ensembl Database Adaptor and consolidate the
** results into an AJAX List of Ensembl Density Type objects.
**
** @param [u] ba [EnsPBaseadaptor] Ensembl Base Adaptor
** @param [r] statement [const AjPStr] SQL statement
** @param [uN] am [EnsPAssemblymapper] Ensembl Assembly Mapper
** @param [uN] slice [EnsPSlice] Ensembl Slice
** @param [u] dts [AjPList] AJAX List of Ensembl Density Types
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.4.0
** @@
******************************************************************************/

static AjBool densitytypeadaptorFetchAllbyStatement(
    EnsPBaseadaptor ba,
    const AjPStr statement,
    EnsPAssemblymapper am,
    EnsPSlice slice,
    AjPList dts)
{
    ajuint identifier = 0U;
    ajuint analysisid = 0U;
    ajuint size       = 0U;
    ajuint features   = 0U;

    EnsEDensitytypeType etype = ensEDensitytypeTypeNULL;

    AjPSqlstatement sqls = NULL;
    AjISqlrow sqli       = NULL;
    AjPSqlrow sqlr       = NULL;

    AjPStr type = NULL;

    EnsPAnalysis analysis  = NULL;
    EnsPAnalysisadaptor aa = NULL;

    EnsPDatabaseadaptor dba = NULL;

    EnsPDensitytype dt         = NULL;
    EnsPDensitytypeadaptor dta = NULL;

    if (ajDebugTest("densitytypeadaptorFetchAllbyStatement"))
        ajDebug("densitytypeadaptorFetchAllbyStatement\n"
                "  ba %p\n"
                "  statement %p\n"
                "  am %p\n"
                "  slice %p\n"
                "  dts %p\n",
                ba,
                statement,
                am,
                slice,
                dts);

    if (!ba)
        return ajFalse;

    if (!statement)
        return ajFalse;

    if (!dts)
        return ajFalse;

    dba = ensBaseadaptorGetDatabaseadaptor(ba);

    aa  = ensRegistryGetAnalysisadaptor(dba);
    dta = ensRegistryGetDensitytypeadaptor(dba);

    sqls = ensDatabaseadaptorSqlstatementNew(dba, statement);

    sqli = ajSqlrowiterNew(sqls);

    while (!ajSqlrowiterDone(sqli))
    {
        identifier = 0;
        analysisid = 0;
        type = ajStrNew();
        size = 0;
        features = 0;
        etype = ensEDensitytypeTypeNULL;

        sqlr = ajSqlrowiterGet(sqli);

        ajSqlcolumnToUint(sqlr, &identifier);
        ajSqlcolumnToUint(sqlr, &analysisid);
        ajSqlcolumnToStr(sqlr, &type);
        ajSqlcolumnToUint(sqlr, &size);
        ajSqlcolumnToUint(sqlr, &features);

        ensAnalysisadaptorFetchByIdentifier(aa, analysisid, &analysis);

        etype = ensDensitytypeTypeFromStr(type);

        dt = ensDensitytypeNewIni(dta,
                                  identifier,
                                  analysis,
                                  etype,
                                  size,
                                  features);

        ajListPushAppend(dts, (void *) dt);

        ensAnalysisDel(&analysis);

        ajStrDel(&type);
    }

    ajSqlrowiterDel(&sqli);

    ensDatabaseadaptorSqlstatementDel(dba, &sqls);

    return ajTrue;
}




/* @funcstatic densitytypeadaptorCacheInsert **********************************
**
** Insert an Ensembl Density Type into the Density Type Adaptor-internal cache.
** If a Density Type with the same identifier member is already present in the
** adaptor cache, the Density Type is deleted and a pointer to the cached
** Density Type is returned.
**
** @param [u] dta [EnsPDensitytypeadaptor] Ensembl Density Type Adaptor
** @param [u] Pdt [EnsPDensitytype*] Ensembl Density Type address
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.3.0
** @@
******************************************************************************/

static AjBool densitytypeadaptorCacheInsert(EnsPDensitytypeadaptor dta,
                                            EnsPDensitytype *Pdt)
{
    ajuint *Pidentifier = NULL;

    EnsPDensitytype dt = NULL;

    if (!dta)
        return ajFalse;

    if (!dta->CacheByIdentifier)
        return ajFalse;

    if (!Pdt)
        return ajFalse;

    if (!*Pdt)
        return ajFalse;

    /* Search the identifier cache. */

    dt = (EnsPDensitytype) ajTableFetchmodV(
        dta->CacheByIdentifier,
        (const void *) &((*Pdt)->Identifier));

    if (dt)
    {
        ajDebug("densitytypeadaptorCacheInsert replaced Density Type %p with "
                "one already cached %p.\n",
                *Pdt, dt);

        ensDensitytypeDel(Pdt);

        ensDensitytypeNewRef(dt);

        Pdt = &dt;
    }
    else
    {
        /* Insert into the identifier cache. */

        AJNEW0(Pidentifier);

        *Pidentifier = (*Pdt)->Identifier;

        ajTablePut(dta->CacheByIdentifier,
                   (void *) Pidentifier,
                   (void *) ensDensitytypeNewRef(*Pdt));
    }

    return ajTrue;
}




/* @funcstatic densitytypeadaptorCacheInit ************************************
**
** Initialise the internal Density Type cache of an
** Ensembl Density Type Adaptor.
**
** @param [u] dta [EnsPDensitytypeadaptor] Ensembl Density Type Adaptor
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.3.0
** @@
******************************************************************************/

static AjBool densitytypeadaptorCacheInit(EnsPDensitytypeadaptor dta)
{
    AjBool result = AJFALSE;

    AjPList dts = NULL;

    EnsPDensitytype dt = NULL;

    if (ajDebugTest("densitytypeadaptorCacheInit"))
        ajDebug("densitytypeadaptorCacheInit\n"
                "  dta %p\n",
                dta);

    if (!dta)
        return ajFalse;

    if (dta->CacheByIdentifier)
        return ajFalse;
    else
    {
        dta->CacheByIdentifier = ajTableuintNew(0U);

        ajTableSetDestroyvalue(
            dta->CacheByIdentifier,
            (void (*)(void **)) &ensDensitytypeDel);
    }

    dts = ajListNew();

    result = ensBaseadaptorFetchAll(
        ensDensitytypeadaptorGetBaseadaptor(dta),
        dts);

    while (ajListPop(dts, (void **) &dt))
    {
        densitytypeadaptorCacheInsert(dta, &dt);

        ensDensitytypeDel(&dt);
    }

    ajListFree(&dts);

    return result;
}




/* @section constructors ******************************************************
**
** All constructors return a new Ensembl Density Type Adaptor by pointer.
** It is the responsibility of the user to first destroy any previous
** Density Type Adaptor. The target pointer does not need to be initialised to
** NULL, but it is good programming practice to do so anyway.
**
** @fdata [EnsPDensitytypeadaptor]
**
** @nam3rule New Constructor
**
** @argrule New dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
**
** @valrule * [EnsPDensitytypeadaptor] Ensembl Density Type Adaptor or NULL
**
** @fcategory new
******************************************************************************/




/* @func ensDensitytypeadaptorNew *********************************************
**
** Default constructor for an Ensembl Density Type Adaptor.
**
** Ensembl Object Adaptors are singleton objects in the sense that a single
** instance of an Ensembl Object Adaptor connected to a particular database is
** sufficient to instantiate any number of Ensembl Objects from the database.
** Each Ensembl Object will have a weak reference to the Object Adaptor that
** instantiated it. Therefore, Ensembl Object Adaptors should not be
** instantiated directly, but rather obtained from the Ensembl Registry,
** which will in turn call this function if neccessary.
**
** @see ensRegistryGetDatabaseadaptor
** @see ensRegistryGetDensitytypeadaptor
**
** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
**
** @return [EnsPDensitytypeadaptor] Ensembl Density Type Adaptor or NULL
**
** @release 6.2.0
** @@
******************************************************************************/

EnsPDensitytypeadaptor ensDensitytypeadaptorNew(
    EnsPDatabaseadaptor dba)
{
    EnsPDensitytypeadaptor dta = NULL;

    if (!dba)
        return NULL;

    if (ajDebugTest("ensDensitytypeadaptorNew"))
        ajDebug("ensDensitytypeadaptorNew\n"
                "  dba %p\n",
                dba);

    AJNEW0(dta);

    dta->Adaptor = ensBaseadaptorNew(
        dba,
        densitytypeadaptorKTablenames,
        densitytypeadaptorKColumnnames,
        (const EnsPBaseadaptorLeftjoin) NULL,
        (const char *) NULL,
        (const char *) NULL,
        &densitytypeadaptorFetchAllbyStatement);

    /*
    ** NOTE: The cache cannot be initialised here because the
    ** densitytypeadaptorCacheInit function calls
    ** ensBaseadaptorFetchAllbyConstraint, which calls
    ** densitytypeadaptorFetchAllbyStatement, which calls
    ** ensRegistryGetDensitytypeadaptor. At that point, however, the
    ** Density Type Adaptor has not been stored in the Registry. Therefore,
    ** each ensDensitytypeadaptorFetch function has to test the presence of
    ** the adaptor-internal cache and eventually initialise before accessing
    ** it.
    **
    ** densitytypeadaptorCacheInit(dta);
    */

    return dta;
}




/* @section destructors *******************************************************
**
** Destruction destroys all internal data structures and frees the memory
** allocated for an Ensembl Density Type Adaptor object.
**
** @fdata [EnsPDensitytypeadaptor]
**
** @nam3rule Del Destroy (free) an Ensembl Density Type Adaptor
**
** @argrule * Pdta [EnsPDensitytypeadaptor*]
** Ensembl Density Type Adaptor address
**
** @valrule * [void]
**
** @fcategory delete
******************************************************************************/




/* @func ensDensitytypeadaptorDel *********************************************
**
** Default destructor for an Ensembl Density Type Adaptor.
**
** This function also clears the internal caches.
**
** Ensembl Object Adaptors are singleton objects that are registered in the
** Ensembl Registry and weakly referenced by Ensembl Objects that have been
** instantiated by it. Therefore, Ensembl Object Adaptors should never be
** destroyed directly. Upon exit, the Ensembl Registry will call this function
** if required.
**
** @param [d] Pdta [EnsPDensitytypeadaptor*]
** Ensembl Density Type Adaptor address
**
** @return [void]
**
** @release 6.2.0
** @@
******************************************************************************/

void ensDensitytypeadaptorDel(EnsPDensitytypeadaptor *Pdta)
{
    EnsPDensitytypeadaptor pthis = NULL;

    if (!Pdta)
        return;

#if defined(AJ_DEBUG) && AJ_DEBUG >= 1
    if (ajDebugTest("ensDensitytypeadaptorDel"))
        ajDebug("ensDensitytypeadaptorDel\n"
                "  Pdta %p\n",
                Pdta);
#endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */

    if (!(pthis = *Pdta))
        return;

    ajTableDel(&pthis->CacheByIdentifier);

    ensBaseadaptorDel(&pthis->Adaptor);

    ajMemFree((void **) Pdta);

    return;
}




/* @section member retrieval **************************************************
**
** Functions for returning members of an Ensembl Density Type Adaptor object.
**
** @fdata [EnsPDensitytypeadaptor]
**
** @nam3rule Get Return Ensembl Density Type Adaptor attribute(s)
** @nam4rule Baseadaptor Return the Ensembl Base Adaptor
** @nam4rule Databaseadaptor Return the Ensembl Databaseadaptor
**
** @argrule * dta [EnsPDensitytypeadaptor] Ensembl Density Type Adaptor
**
** @valrule Baseadaptor [EnsPBaseadaptor] Ensembl Base Adaptor or NULL
** @valrule Databaseadaptor [EnsPDatabaseadaptor] Ensembl Database Adaptor
**                                                or NULL
**
** @fcategory use
******************************************************************************/




/* @func ensDensitytypeadaptorGetBaseadaptor **********************************
**
** Get the Ensembl Base Adaptor member of an Ensembl Density Type Adaptor.
**
** @param [u] dta [EnsPDensitytypeadaptor] Ensembl Density Type Adaptor
**
** @return [EnsPBaseadaptor] Ensembl Base Adaptor or NULL
**
** @release 6.2.0
** @@
******************************************************************************/

EnsPBaseadaptor ensDensitytypeadaptorGetBaseadaptor(
    EnsPDensitytypeadaptor dta)
{
    return (dta) ? dta->Adaptor : NULL;
}




/* @func ensDensitytypeadaptorGetDatabaseadaptor ******************************
**
** Get the Ensembl Database Adaptor member of an Ensembl Density Type Adaptor.
**
** @param [u] dta [EnsPDensitytypeadaptor] Ensembl Density Type Adaptor
**
** @return [EnsPDatabaseadaptor] Ensembl Database Adaptor
**
** @release 6.2.0
** @@
******************************************************************************/

EnsPDatabaseadaptor ensDensitytypeadaptorGetDatabaseadaptor(
    EnsPDensitytypeadaptor dta)
{
    return ensBaseadaptorGetDatabaseadaptor(
        ensDensitytypeadaptorGetBaseadaptor(dta));
}




/* @section object retrieval **************************************************
**
** Functions for fetching Ensembl Density Type objects from an
** Ensembl SQL database.
**
** @fdata [EnsPDensitytypeadaptor]
**
** @nam3rule Fetch Fetch Ensembl Density Type object(s)
** @nam4rule All Fetch all Ensembl Density Type objects
** @nam4rule Allby Fetch all Ensembl Density Type objects matching a criterion
** @nam5rule AllbyAnalysisname Fetch all by an Ensembl Analysis name
** @nam4rule By Fetch one Ensembl Density Type object matching a criterion
** @nam5rule ByIdentifier Fetch by an SQL database-internal identifier
**
** @argrule * dta [EnsPDensitytypeadaptor] Ensembl Density Type Adaptor
** @argrule All dts [AjPList] AJAX List of Ensembl Density Type objects
** @argrule AllbyAnalysisname name [const AjPStr] Ensembl Analysis name
** @argrule AllbyAnalysisname dts [AjPList] AJAX List of Ensembl Density Type
**                                          objects
** @argrule ByIdentifier identifier [ajuint] SQL database-internal identifier
** @argrule ByIdentifier Pdt [EnsPDensitytype*] Ensembl Density Type address
**
** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
**
** @fcategory use
******************************************************************************/




/* @funcstatic densitytypeadaptorFetchAll *************************************
**
** An ajTableMap "apply" function to return all Density Type objects from the
** Ensembl Density Type Adaptor-internal cache.
**
** @param [u] key [const void*] AJAX unsigned integer key data address
** @param [d] Pvalue [void**] Ensembl Density Type value data address
** @param [u] cl [void*] AJAX List of Ensembl Density Type objects,
**                       passed in via ajTableMap
** @see ajTableMap
**
** @return [void]
**
** @release 6.3.0
** @@
******************************************************************************/

static void densitytypeadaptorFetchAll(const void *key,
                                       void **Pvalue,
                                       void *cl)
{
    if (!key)
        return;

    if (!Pvalue)
        return;

    if (!*Pvalue)
        return;

    if (!cl)
        return;

    ajListPushAppend((AjPList) cl,
                     (void *)
                     ensDensitytypeNewRef(*((EnsPDensitytype *) Pvalue)));

    return;
}




/* @func ensDensitytypeadaptorFetchAll ****************************************
**
** Fetch all Ensembl Density Type objects.
**
** The caller is responsible for deleting the Ensembl Density Type objects
** before deleting the AJAX List.
**
** @param [u] dta [EnsPDensitytypeadaptor] Ensembl Density Type Adaptor
** @param [u] dts [AjPList] AJAX List of Ensembl Density Type objects
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.2.0
** @@
******************************************************************************/

AjBool ensDensitytypeadaptorFetchAll(
    EnsPDensitytypeadaptor dta,
    AjPList dts)
{
    if (!dta)
        return ajFalse;

    if (!dts)
        return ajFalse;

    if (!dta->CacheByIdentifier)
        densitytypeadaptorCacheInit(dta);

    ajTableMap(dta->CacheByIdentifier,
               &densitytypeadaptorFetchAll,
               (void *) dts);

    return ajTrue;
}




/* @func ensDensitytypeadaptorFetchAllbyAnalysisname **************************
**
** Fetch all Ensembl Density Types by an Ensembl Analysis name.
**
** The caller is responsible for deleting the Ensembl Density Type objects
** before deleting the AJAX List.
**
** @param [u] dta [EnsPDensitytypeadaptor] Ensembl Density Type Adaptor
** @param [r] name [const AjPStr] Ensembl Analysis name
** @param [u] dts [AjPList] AJAX List of Ensembl Density Type objects
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.4.0
** @@
******************************************************************************/

AjBool ensDensitytypeadaptorFetchAllbyAnalysisname(
    EnsPDensitytypeadaptor dta,
    const AjPStr name,
    AjPList dts)
{
    void **keyarray = NULL;
    void **valarray = NULL;

    register ajuint i = 0U;

    EnsPAnalysis analysis = NULL;

    if (!dta)
        return ajFalse;

    if (!name)
        return ajFalse;

    if (!dts)
        return ajFalse;

    if (!dta->CacheByIdentifier)
        densitytypeadaptorCacheInit(dta);

    ajTableToarrayKeysValues(dta->CacheByIdentifier, &keyarray, &valarray);

    for (i = 0U; keyarray[i]; i++)
    {
        analysis = ensDensitytypeGetAnalysis((EnsPDensitytype) valarray[i]);

        if (ajStrMatchS(name, ensAnalysisGetName(analysis)))
        {
            ajListPushAppend(dts, (void *)
                             ensDensitytypeNewRef((EnsPDensitytype)
                                                  valarray[i]));
        }
    }

    AJFREE(keyarray);
    AJFREE(valarray);

    return ajTrue;
}




/* @func ensDensitytypeadaptorFetchByIdentifier *******************************
**
** Fetch an Ensembl Density Type by its SQL database-internal identifier.
** The caller is responsible for deleting the Ensembl Density Type.
**
** @param [u] dta [EnsPDensitytypeadaptor] Ensembl Density Type Adaptor
** @param [r] identifier [ajuint] SQL database-internal identifier
** @param [wP] Pdt [EnsPDensitytype*] Ensembl Density Type address
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.2.0
** @@
******************************************************************************/

AjBool ensDensitytypeadaptorFetchByIdentifier(
    EnsPDensitytypeadaptor dta,
    ajuint identifier,
    EnsPDensitytype *Pdt)
{
    AjBool result = AJFALSE;

    if (!dta)
        return ajFalse;

    if (!identifier)
        return ajFalse;

    if (!Pdt)
        return ajFalse;

    /*
    ** Initially, search the identifier cache.
    ** For any object returned by the AJAX Table the reference counter needs
    ** to be incremented manually.
    */

    if (!dta->CacheByIdentifier)
        densitytypeadaptorCacheInit(dta);

    *Pdt = (EnsPDensitytype) ajTableFetchmodV(dta->CacheByIdentifier,
                                              (const void *) &identifier);

    if (*Pdt)
    {
        ensDensitytypeNewRef(*Pdt);

        return ajTrue;
    }

    /* For a cache miss re-query the database. */

    result = ensBaseadaptorFetchByIdentifier(
        ensDensitytypeadaptorGetBaseadaptor(dta),
        identifier,
        (void **) Pdt);

    densitytypeadaptorCacheInsert(dta, Pdt);

    return result;
}




/* @datasection [EnsPDensityfeature] Ensembl Density Feature ******************
**
** @nam2rule Densityfeature Functions for manipulating
** Ensembl Density Feature objects
**
** @cc Bio::EnsEMBL::DensityFeature
** @cc CVS Revision: 1.14
** @cc CVS Tag: branch-ensembl-68
**
******************************************************************************/




/* @section constructors ******************************************************
**
** All constructors return a new Ensembl Density Feature by pointer.
** It is the responsibility of the user to first destroy any previous
** Density Feature. The target pointer does not need to be initialised to
** NULL, but it is good programming practice to do so anyway.
**
** @fdata [EnsPDensityfeature]
**
** @nam3rule New Constructor
** @nam4rule Cpy Constructor with existing object
** @nam4rule Ini Constructor with initial values
** @nam4rule Ref Constructor by incrementing the reference counter
**
** @argrule Cpy df [const EnsPDensityfeature] Ensembl Density Feature
** @argrule Ini dfa [EnsPDensityfeatureadaptor] Ensembl Density Feature Adaptor
** @argrule Ini identifier [ajuint] SQL database-internal identifier
** @argrule Ini feature [EnsPFeature] Ensembl Feature
** @argrule Ini dt [EnsPDensitytype] Ensembl Density Type
** @argrule Ini value [float] Density value
** @argrule Ref df [EnsPDensityfeature] Ensembl Density Feature
**
** @valrule * [EnsPDensityfeature] Ensembl Density Feature or NULL
**
** @fcategory new
******************************************************************************/




/* @func ensDensityfeatureNewCpy **********************************************
**
** Object-based constructor function, which returns an independent object.
**
** @param [r] df [const EnsPDensityfeature] Ensembl Density Feature
**
** @return [EnsPDensityfeature] Ensembl Density Feature or NULL
**
** @release 6.4.0
** @@
******************************************************************************/

EnsPDensityfeature ensDensityfeatureNewCpy(const EnsPDensityfeature df)
{
    EnsPDensityfeature pthis = NULL;

    if (!df)
        return NULL;

    AJNEW0(pthis);

    pthis->Use         = 1U;
    pthis->Identifier  = df->Identifier;
    pthis->Adaptor     = df->Adaptor;
    pthis->Feature     = ensFeatureNewRef(df->Feature);
    pthis->Densitytype = ensDensitytypeNewRef(df->Densitytype);
    pthis->Value       = df->Value;

    return pthis;
}




/* @func ensDensityfeatureNewIni **********************************************
**
** Constructor for an Ensembl Density Feature with initial values.
**
** @cc Bio::EnsEMBL::Storable::new
** @param [u] dfa [EnsPDensityfeatureadaptor] Ensembl Density Feature Adaptor
** @param [r] identifier [ajuint] SQL database-internal identifier
** @cc Bio::EnsEMBL::Feature::new
** @param [u] feature [EnsPFeature] Ensembl Feature
** @cc Bio::EnsEMBL::DensityFeature::new
** @param [u] dt [EnsPDensitytype] Ensembl Density Type
** @param [r] value [float] Density value
**
** @return [EnsPDensityfeature] Ensembl Density Feature or NULL
**
** @release 6.4.0
** @@
******************************************************************************/

EnsPDensityfeature ensDensityfeatureNewIni(EnsPDensityfeatureadaptor dfa,
                                           ajuint identifier,
                                           EnsPFeature feature,
                                           EnsPDensitytype dt,
                                           float value)
{
    EnsPDensityfeature df = NULL;

    if (!feature)
        return NULL;

    AJNEW0(df);

    df->Use         = 1U;
    df->Identifier  = identifier;
    df->Adaptor     = dfa;
    df->Feature     = ensFeatureNewRef(feature);
    df->Densitytype = ensDensitytypeNewRef(dt);
    df->Value       = value;

    return df;
}




/* @func ensDensityfeatureNewRef **********************************************
**
** Ensembl Object referencing function, which returns a pointer to the
** Ensembl Object passed in and increases its reference count.
**
** @param [u] df [EnsPDensityfeature] Ensembl Density Feature
**
** @return [EnsPDensityfeature] Ensembl Density Feature or NULL
**
** @release 6.2.0
** @@
******************************************************************************/

EnsPDensityfeature ensDensityfeatureNewRef(EnsPDensityfeature df)
{
    if (!df)
        return NULL;

    df->Use++;

    return df;
}




/* @section destructors *******************************************************
**
** Destruction destroys all internal data structures and frees the memory
** allocated for an Ensembl Density Feature object.
**
** @fdata [EnsPDensityfeature]
**
** @nam3rule Del Destroy (free) an Ensembl Density Feature
**
** @argrule * Pdf [EnsPDensityfeature*] Ensembl Density Feature address
**
** @valrule * [void]
**
** @fcategory delete
******************************************************************************/




/* @func ensDensityfeatureDel *************************************************
**
** Default destructor for an Ensembl Density Feature.
**
** @param [d] Pdf [EnsPDensityfeature*] Ensembl Density Feature address
**
** @return [void]
**
** @release 6.2.0
** @@
******************************************************************************/

void ensDensityfeatureDel(EnsPDensityfeature *Pdf)
{
    EnsPDensityfeature pthis = NULL;

    if (!Pdf)
        return;

#if defined(AJ_DEBUG) && AJ_DEBUG >= 1
    if (ajDebugTest("ensDensityfeatureDel"))
    {
        ajDebug("ensDensityfeatureDel\n"
                "  *Pdf %p\n",
                *Pdf);

        ensDensityfeatureTrace(*Pdf, 1);
    }
#endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */

    if (!(pthis = *Pdf) || --pthis->Use)
    {
        *Pdf = NULL;

        return;
    }

    ensFeatureDel(&pthis->Feature);

    ensDensitytypeDel(&pthis->Densitytype);

    ajMemFree((void **) Pdf);

    return;
}




/* @section member retrieval **************************************************
**
** Functions for returning members of an Ensembl Density Feature object.
**
** @fdata [EnsPDensityfeature]
**
** @nam3rule Get Return Density Feature attribute(s)
** @nam4rule Adaptor Return the Ensembl Density Feature Adaptor
** @nam4rule Feature Return the Ensembl Feature
** @nam4rule Identifier Return the SQL database-internal identifier
** @nam4rule Densitytype Return the Ensembl Density Type
** @nam4rule Value Return the value
**
** @argrule * df [const EnsPDensityfeature] Density Feature
**
** @valrule Adaptor [EnsPDensityfeatureadaptor] Ensembl Density Feature Adaptor
** or NULL
** @valrule Feature [EnsPFeature] Ensembl Feature or NULL
** @valrule Identifier [ajuint] SQL database-internal identifier or 0
** @valrule Densitytype [EnsPDensitytype] Ensembl Density Type or
** ensEDensitytypeTypeNULL
** @valrule Value [float] Value or 0.0F
**
** @fcategory use
******************************************************************************/




/* @func ensDensityfeatureGetAdaptor ******************************************
**
** Get the Ensembl Density Feature Adaptor member of an
** Ensembl Density Feature.
**
** @cc Bio::EnsEMBL::Storable::adaptor
** @param [r] df [const EnsPDensityfeature] Ensembl Density Feature
**
** @return [EnsPDensityfeatureadaptor] Ensembl Density Feature Adaptor or NULL
**
** @release 6.2.0
** @@
******************************************************************************/

EnsPDensityfeatureadaptor ensDensityfeatureGetAdaptor(
    const EnsPDensityfeature df)
{
    return (df) ? df->Adaptor : NULL;
}




/* @func ensDensityfeatureGetDensitytype **************************************
**
** Get the Ensembl Density Type member of an Ensembl Density Feature.
**
** @cc Bio::EnsEMBL::DensityFeature::density_type
** @param [r] df [const EnsPDensityfeature] Ensembl Density Feature
**
** @return [EnsPDensitytype] Ensembl Density Type or NULL
**
** @release 6.2.0
** @@
******************************************************************************/

EnsPDensitytype ensDensityfeatureGetDensitytype(const EnsPDensityfeature df)
{
    if (!df)
        return NULL;

    return (df) ? df->Densitytype : NULL;
}




/* @func ensDensityfeatureGetFeature ******************************************
**
** Get the Ensembl Feature member of an Ensembl Density Feature.
**
** @param [r] df [const EnsPDensityfeature] Ensembl Density Feature
**
** @return [EnsPFeature] Ensembl Feature or NULL
**
** @release 6.2.0
** @@
******************************************************************************/

EnsPFeature ensDensityfeatureGetFeature(const EnsPDensityfeature df)
{
    return (df) ? df->Feature : NULL;
}




/* @func ensDensityfeatureGetIdentifier ***************************************
**
** Get the SQL database-internal identifier member of an
** Ensembl Density Feature.
**
** @cc Bio::EnsEMBL::Storable::dbID
** @param [r] df [const EnsPDensityfeature] Ensembl Density Feature
**
** @return [ajuint] SQL database-internal identifier or 0U
**
** @release 6.2.0
** @@
******************************************************************************/

ajuint ensDensityfeatureGetIdentifier(const EnsPDensityfeature df)
{
    return (df) ? df->Identifier : 0U;
}




/* @func ensDensityfeatureGetValue ********************************************
**
** Get the value member of an Ensembl Density Feature.
**
** @cc Bio::EnsEMBL::DensityFeature::density_value
** @param [r] df [const EnsPDensityfeature] Ensembl Density Feature
**
** @return [float] Value or 0.0F
**
** @release 6.4.0
** @@
******************************************************************************/

float ensDensityfeatureGetValue(const EnsPDensityfeature df)
{
    return (df) ? df->Value : 0.0F;
}




/* @section member assignment *************************************************
**
** Functions for assigning members of an Ensembl Density Feature object.
**
** @fdata [EnsPDensityfeature]
**
** @nam3rule Set Set one member of a Density Feature
** @nam4rule Adaptor Set the Ensembl Density Feature Adaptor
** @nam4rule Densitytype Set the Ensembl Density Type
** @nam4rule Feature Set the Ensembl Feature
** @nam4rule Identifier Set the SQL database-internal identifier
** @nam4rule Value Set the value
**
** @argrule * df [EnsPDensityfeature] Ensembl Density Feature object
**
** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
** @argrule Adaptor dfa [EnsPDensityfeatureadaptor] Ensembl Density Feature
**                                                  Adaptor
** @argrule Densitytype dt [EnsPDensitytype] Ensembl Density Type
** @argrule Feature feature [EnsPFeature] Ensembl Feature
** @argrule Identifier identifier [ajuint] SQL database-internal identifier
** @argrule Value value [float] Value
**
** @fcategory modify
******************************************************************************/




/* @func ensDensityfeatureSetAdaptor ******************************************
**
** Set the Ensembl Density Feature Adaptor member of an
** Ensembl Density Feature.
**
** @cc Bio::EnsEMBL::Storable::adaptor
** @param [u] df [EnsPDensityfeature] Ensembl Density Feature
** @param [u] dfa [EnsPDensityfeatureadaptor] Ensembl Density Feature Adaptor
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.2.0
** @@
******************************************************************************/

AjBool ensDensityfeatureSetAdaptor(EnsPDensityfeature df,
                                   EnsPDensityfeatureadaptor dfa)
{
    if (!df)
        return ajFalse;

    df->Adaptor = dfa;

    return ajTrue;
}




/* @func ensDensityfeatureSetDensitytype **************************************
**
** Set the Ensembl Density Type member of an Ensembl Density Feature.
**
** @cc Bio::EnsEMBL::DensityFeature::density_type
** @param [u] df [EnsPDensityfeature] Ensembl Density Feature
** @param [u] dt [EnsPDensitytype] Ensembl Density Type
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.2.0
** @@
******************************************************************************/

AjBool ensDensityfeatureSetDensitytype(EnsPDensityfeature df,
                                       EnsPDensitytype dt)
{
    if (!df)
        return ajFalse;

    ensDensitytypeDel(&df->Densitytype);

    df->Densitytype = ensDensitytypeNewRef(dt);

    return ajTrue;
}




/* @func ensDensityfeatureSetFeature ******************************************
**
** Set the Ensembl Feature member of an Ensembl Density Feature.
**
** @param [u] df [EnsPDensityfeature] Ensembl Density Feature
** @param [u] feature [EnsPFeature] Ensembl Feature
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.2.0
** @@
******************************************************************************/

AjBool ensDensityfeatureSetFeature(EnsPDensityfeature df,
                                   EnsPFeature feature)
{
    if (!df)
        return ajFalse;

    ensFeatureDel(&df->Feature);

    df->Feature = ensFeatureNewRef(feature);

    return ajTrue;
}




/* @func ensDensityfeatureSetIdentifier ***************************************
**
** Set the SQL database-internal identifier member of an
** Ensembl Density Feature.
**
** @cc Bio::EnsEMBL::Storable::dbID
** @param [u] df [EnsPDensityfeature] Ensembl Density Feature
** @param [r] identifier [ajuint] SQL database-internal identifier
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.2.0
** @@
******************************************************************************/

AjBool ensDensityfeatureSetIdentifier(EnsPDensityfeature df,
                                      ajuint identifier)
{
    if (!df)
        return ajFalse;

    df->Identifier = identifier;

    return ajTrue;
}




/* @func ensDensityfeatureSetValue ********************************************
**
** Set the value member of an Ensembl Density Feature.
**
** @cc Bio::EnsEMBL::DensityFeature::density_value
** @param [u] df [EnsPDensityfeature] Ensembl Density Feature
** @param [r] value [float] Value
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.4.0
** @@
******************************************************************************/

AjBool ensDensityfeatureSetValue(EnsPDensityfeature df,
                                 float value)
{
    if (!df)
        return ajFalse;

    df->Value = value;

    return ajTrue;
}




/* @section debugging *********************************************************
**
** Functions for reporting of an Ensembl Density Feature object.
**
** @fdata [EnsPDensityfeature]
**
** @nam3rule Trace Report Ensembl Density Feature members to debug file
**
** @argrule Trace df [const EnsPDensityfeature] Ensembl Density Feature
** @argrule Trace level [ajuint] Indentation level
**
** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
**
** @fcategory misc
******************************************************************************/




/* @func ensDensityfeatureTrace ***********************************************
**
** Trace an Ensembl Density Feature.
**
** @param [r] df [const EnsPDensityfeature] Ensembl Density Feature
** @param [r] level [ajuint] Indentation level
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.2.0
** @@
******************************************************************************/

AjBool ensDensityfeatureTrace(const EnsPDensityfeature df, ajuint level)
{
    AjPStr indent = NULL;

    if (!df)
        return ajFalse;

    indent = ajStrNew();

    ajStrAppendCountK(&indent, ' ', level * 2);

    ajDebug("%SensDensityfeatureTrace %p\n"
            "%S  Use %u\n"
            "%S  Identifier %u\n"
            "%S  Adaptor %p\n"
            "%S  Feature %p\n"
            "%S  Densitytype %p\n"
            "%S  Value %f\n",
            indent, df,
            indent, df->Use,
            indent, df->Identifier,
            indent, df->Adaptor,
            indent, df->Feature,
            indent, df->Densitytype,
            indent, df->Value);

    ensFeatureTrace(df->Feature, level + 1);

    ensDensitytypeTrace(df->Densitytype, level + 1);

    ajStrDel(&indent);

    return ajTrue;
}




/* @section calculate *********************************************************
**
** Functions for calculating information from an
** Ensembl Density Feature object.
**
** @fdata [EnsPDensityfeature]
**
** @nam3rule Calculate Calculate Ensembl Density Feature information
** @nam4rule Memsize Calculate the memory size in bytes
**
** @argrule * df [const EnsPDensityfeature] Ensembl Density Feature
**
** @valrule Memsize [size_t] Memory size in bytes or 0
**
** @fcategory misc
******************************************************************************/




/* @func ensDensityfeatureCalculateMemsize ************************************
**
** Calculate the memory size in bytes of an Ensembl Density Feature.
**
** @param [r] df [const EnsPDensityfeature] Ensembl Density Feature
**
** @return [size_t] Memory size in bytes or 0
**
** @release 6.4.0
** @@
******************************************************************************/

size_t ensDensityfeatureCalculateMemsize(const EnsPDensityfeature df)
{
    size_t size = 0;

    if (!df)
        return 0;

    size += sizeof (EnsODensityfeature);

    size += ensFeatureCalculateMemsize(df->Feature);

    size += ensDensitytypeCalculateMemsize(df->Densitytype);

    return size;
}




/* @datasection [AjPList] AJAX List *******************************************
**
** @nam2rule List Functions for manipulating AJAX List objects
**
******************************************************************************/




/* @funcstatic listDensityfeatureCompareEndAscending **************************
**
** AJAX List of Ensembl Density Feature objects comparison function to sort by
** Ensembl Feature end coordinate in ascending order.
**
** @param [r] item1 [const void*] Ensembl Density Feature address 1
** @param [r] item2 [const void*] Ensembl Density Feature address 2
** @see ajListSort
**
** @return [int] The comparison function returns an integer less than,
**               equal to, or greater than zero if the first argument is
**               considered to be respectively less than, equal to, or
**               greater than the second.
**
** @release 6.4.0
** @@
******************************************************************************/

static int listDensityfeatureCompareEndAscending(
    const void *item1,
    const void *item2)
{
    EnsPDensityfeature df1 = *(EnsODensityfeature *const *) item1;
    EnsPDensityfeature df2 = *(EnsODensityfeature *const *) item2;

#if defined(AJ_DEBUG) && AJ_DEBUG >= 2
    if (ajDebugTest("listDensityfeatureCompareEndAscending"))
        ajDebug("listDensityfeatureCompareEndAscending\n"
                "  df1 %p\n"
                "  df2 %p\n",
                df1,
                df2);
#endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 2 */

    /* Sort empty values towards the end of the AJAX List. */

    if (df1 && (!df2))
        return -1;

    if ((!df1) && (!df2))
        return 0;

    if ((!df1) && df2)
        return +1;

    return ensFeatureCompareEndAscending(df1->Feature, df2->Feature);
}




/* @funcstatic listDensityfeatureCompareEndDescending *************************
**
** AJAX List of Ensembl Density Feature objects comparison function to sort by
** Ensembl Feature end coordinate in descending order.
**
** @param [r] item1 [const void*] Ensembl Density Feature address 1
** @param [r] item2 [const void*] Ensembl Density Feature address 2
** @see ajListSort
**
** @return [int] The comparison function returns an integer less than,
**               equal to, or greater than zero if the first argument is
**               considered to be respectively less than, equal to, or
**               greater than the second.
**
** @release 6.4.0
** @@
******************************************************************************/

static int listDensityfeatureCompareEndDescending(
    const void *item1,
    const void *item2)
{
    EnsPDensityfeature df1 = *(EnsODensityfeature *const *) item1;
    EnsPDensityfeature df2 = *(EnsODensityfeature *const *) item2;

#if defined(AJ_DEBUG) && AJ_DEBUG >= 2
    if (ajDebugTest("listDensityfeatureCompareEndDescending"))
        ajDebug("listDensityfeatureCompareEndDescending\n"
                "  df1 %p\n"
                "  df2 %p\n",
                df1,
                df2);
#endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 2 */

    /* Sort empty values towards the end of the AJAX List. */

    if (df1 && (!df2))
        return -1;

    if ((!df1) && (!df2))
        return 0;

    if ((!df1) && df2)
        return +1;

    return ensFeatureCompareEndDescending(df1->Feature, df2->Feature);
}




/* @funcstatic listDensityfeatureCompareIdentifierAscending *******************
**
** AJAX List of Ensembl Density Feature objects comparison function to sort by
** identifier in ascending order.
**
** @param [r] item1 [const void*] Ensembl Density Feature address 1
** @param [r] item2 [const void*] Ensembl Density Feature address 2
** @see ajListSort
**
** @return [int] The comparison function returns an integer less than,
**               equal to, or greater than zero if the first argument is
**               considered to be respectively less than, equal to, or
**               greater than the second.
**
** @release 6.4.0
** @@
******************************************************************************/

static int listDensityfeatureCompareIdentifierAscending(
    const void *item1,
    const void *item2)
{
    EnsPDensityfeature df1 = *(EnsODensityfeature *const *) item1;
    EnsPDensityfeature df2 = *(EnsODensityfeature *const *) item2;

#if defined(AJ_DEBUG) && AJ_DEBUG >= 2
    if (ajDebugTest("listDensityfeatureCompareIdentifierAscending"))
        ajDebug("listDensityfeatureCompareIdentifierAscending\n"
                "  df1 %p\n"
                "  df2 %p\n",
                df1,
                df2);
#endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 2 */

    /* Sort empty values towards the end of the AJAX List. */

    if (df1 && (!df2))
        return -1;

    if ((!df1) && (!df2))
        return 0;

    if ((!df1) && df2)
        return +1;

    if (df1->Identifier < df2->Identifier)
        return -1;

    if (df1->Identifier > df2->Identifier)
        return +1;

    return 0;
}




/* @funcstatic listDensityfeatureCompareStartAscending ************************
**
** AJAX List of Ensembl Density Feature objects comparison function to sort by
** Ensembl Feature start coordinate in ascending order.
**
** @param [r] item1 [const void*] Ensembl Density Feature address 1
** @param [r] item2 [const void*] Ensembl Density Feature address 2
** @see ajListSort
**
** @return [int] The comparison function returns an integer less than,
**               equal to, or greater than zero if the first argument is
**               considered to be respectively less than, equal to, or
**               greater than the second.
**
** @release 6.4.0
** @@
******************************************************************************/

static int listDensityfeatureCompareStartAscending(
    const void *item1,
    const void *item2)
{
    EnsPDensityfeature df1 = *(EnsODensityfeature *const *) item1;
    EnsPDensityfeature df2 = *(EnsODensityfeature *const *) item2;

#if defined(AJ_DEBUG) && AJ_DEBUG >= 2
    if (ajDebugTest("listDensityfeatureCompareStartAscending"))
        ajDebug("listDensityfeatureCompareStartAscending\n"
                "  df1 %p\n"
                "  df2 %p\n",
                df1,
                df2);
#endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 2 */

    /* Sort empty values towards the end of the AJAX List. */

    if (df1 && (!df2))
        return -1;

    if ((!df1) && (!df2))
        return 0;

    if ((!df1) && df2)
        return +1;

    return ensFeatureCompareStartAscending(df1->Feature, df2->Feature);
}




/* @funcstatic listDensityfeatureCompareStartDescending ***********************
**
** AJAX List of Ensembl Density Feature objects comparison function to sort by
** Ensembl Feature start coordinate in descending order.
**
** @param [r] item1 [const void*] Ensembl Density Feature address 1
** @param [r] item2 [const void*] Ensembl Density Feature address 2
** @see ajListSort
**
** @return [int] The comparison function returns an integer less than,
**               equal to, or greater than zero if the first argument is
**               considered to be respectively less than, equal to, or
**               greater than the second.
**
** @release 6.4.0
** @@
******************************************************************************/

static int listDensityfeatureCompareStartDescending(
    const void *item1,
    const void *item2)
{
    EnsPDensityfeature df1 = *(EnsODensityfeature *const *) item1;
    EnsPDensityfeature df2 = *(EnsODensityfeature *const *) item2;

#if defined(AJ_DEBUG) && AJ_DEBUG >= 2
    if (ajDebugTest("listDensityfeatureCompareStartDescending"))
        ajDebug("listDensityfeatureCompareStartDescending\n"
                "  df1 %p\n"
                "  df2 %p\n",
                df1,
                df2);
#endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 2 */

    /* Sort empty values towards the end of the AJAX List. */

    if (df1 && (!df2))
        return -1;

    if ((!df1) && (!df2))
        return 0;

    if ((!df1) && df2)
        return +1;

    return ensFeatureCompareStartDescending(df1->Feature, df2->Feature);
}




/* @section list **************************************************************
**
** Functions for manipulating AJAX List objects.
**
** @fdata [AjPList]
**
** @nam3rule Densityfeature Functions for manipulating AJAX List objects of
** Ensembl Density Feature objects
** @nam4rule Sort       Sort functions
** @nam5rule Start      Sort by Ensembl Feature start member
** @nam5rule Identifier Sort by identifier member
** @nam5rule End        Sort by Ensembl Feature end member
** @nam6rule Ascending  Sort in ascending order
** @nam6rule Descending Sort in descending order
**
** @argrule * dfs [AjPList]
** AJAX List of Ensembl Density Feature objects
**
** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
**
** @fcategory misc
******************************************************************************/




/* @func ensListDensityfeatureSortEndAscending ********************************
**
** Sort an AJAX List of Ensembl Density Feature objects by their
** Ensembl Feature end member in ascending order.
**
** @param [u] dfs [AjPList] AJAX List of Ensembl Density Feature objects
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.4.0
** @@
******************************************************************************/

AjBool ensListDensityfeatureSortEndAscending(AjPList dfs)
{
    if (!dfs)
        return ajFalse;

    ajListSortTwoThree(dfs,
                       &listDensityfeatureCompareEndAscending,
                       &listDensityfeatureCompareStartAscending,
                       &listDensityfeatureCompareIdentifierAscending);

    return ajTrue;
}




/* @func ensListDensityfeatureSortEndDescending *******************************
**
** Sort an AJAX List of Ensembl Density Feature objects by their
** Ensembl Feature end member in descending order.
**
** @param [u] dfs [AjPList] AJAX List of Ensembl Density Feature objects
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.4.0
** @@
******************************************************************************/

AjBool ensListDensityfeatureSortEndDescending(AjPList dfs)
{
    if (!dfs)
        return ajFalse;

    ajListSortTwoThree(dfs,
                       &listDensityfeatureCompareEndDescending,
                       &listDensityfeatureCompareStartDescending,
                       &listDensityfeatureCompareIdentifierAscending);

    return ajTrue;
}




/* @func ensListDensityfeatureSortIdentifierAscending *************************
**
** Sort an AJAX List of Ensembl Density Feature objects by their
** identifier member in ascending order.
**
** @param [u] dfs [AjPList] AJAX List of Ensembl Density Feature objects
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.4.0
** @@
******************************************************************************/

AjBool ensListDensityfeatureSortIdentifierAscending(AjPList dfs)
{
    if (!dfs)
        return ajFalse;

    ajListSort(dfs, &listDensityfeatureCompareIdentifierAscending);

    return ajTrue;
}




/* @func ensListDensityfeatureSortStartAscending ******************************
**
** Sort an AJAX List of Ensembl Density Feature objects by their
** Ensembl Feature start member in ascending order.
**
** @param [u] dfs [AjPList] AJAX List of Ensembl Density Feature objects
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.4.0
** @@
******************************************************************************/

AjBool ensListDensityfeatureSortStartAscending(AjPList dfs)
{
    if (!dfs)
        return ajFalse;

    ajListSortTwoThree(dfs,
                       &listDensityfeatureCompareStartAscending,
                       &listDensityfeatureCompareEndAscending,
                       &listDensityfeatureCompareIdentifierAscending);

    return ajTrue;
}




/* @func ensListDensityfeatureSortStartDescending *****************************
**
** Sort an AJAX List of Ensembl Density Feature objects by their
** Ensembl Feature start member in descending order.
**
** @param [u] dfs [AjPList] AJAX List of Ensembl Density Feature objects
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.4.0
** @@
******************************************************************************/

AjBool ensListDensityfeatureSortStartDescending(AjPList dfs)
{
    if (!dfs)
        return ajFalse;

    ajListSortTwoThree(dfs,
                       &listDensityfeatureCompareStartDescending,
                       &listDensityfeatureCompareEndDescending,
                       &listDensityfeatureCompareIdentifierAscending);

    return ajTrue;
}




/* @datasection [EnsPDensityfeatureadaptor] Ensembl Density Feature Adaptor ***
**
** @nam2rule Densityfeatureadaptor Functions for manipulating
** Ensembl Density Feature Adaptor objects
**
** @cc Bio::EnsEMBL::DBSQL::DensityFeatureAdaptor
** @cc CVS Revision: 1.28
** @cc CVS Tag: branch-ensembl-68
**
******************************************************************************/




/* @funcstatic densityfeatureadaptorFetchAllbyStatement ***********************
**
** Fetch all Ensembl Density Feature objects via an SQL statement.
**
** @cc Bio::EnsEMBL::DBSQL::DensityFeatureAdaptor::_objs_from_sth
** @param [u] ba [EnsPBaseadaptor] Ensembl Base Adaptor
** @param [r] statement [const AjPStr] SQL statement
** @param [uN] am [EnsPAssemblymapper] Ensembl Assembly Mapper
** @param [uN] slice [EnsPSlice] Ensembl Slice
** @param [u] dfs [AjPList] AJAX List of Ensembl Density Feature objects
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.4.0
** @@
******************************************************************************/

static AjBool densityfeatureadaptorFetchAllbyStatement(
    EnsPBaseadaptor ba,
    const AjPStr statement,
    EnsPAssemblymapper am,
    EnsPSlice slice,
    AjPList dfs)
{
    float value = 0.0F;

    ajuint identifier = 0U;
    ajuint dtid       = 0U;

    ajuint srid     = 0U;
    ajuint srstart  = 0U;
    ajuint srend    = 0U;
    ajuint srstrand = 1;

    AjPSqlstatement sqls = NULL;
    AjISqlrow sqli       = NULL;
    AjPSqlrow sqlr       = NULL;

    EnsPDatabaseadaptor dba = NULL;

    EnsPFeature feature = NULL;

    EnsPDensityfeature df         = NULL;
    EnsPDensityfeatureadaptor dfa = NULL;

    EnsPDensitytype dt         = NULL;
    EnsPDensitytypeadaptor dta = NULL;

    if (ajDebugTest("densityfeatureadaptorFetchAllbyStatement"))
        ajDebug("densityfeatureadaptorFetchAllbyStatement\n"
                "  ba %p\n"
                "  statement %p\n"
                "  am %p\n"
                "  slice %p\n"
                "  dfs %p\n",
                ba,
                statement,
                am,
                slice,
                dfs);

    if (!ba)
        return ajFalse;

    if (!statement)
        return ajFalse;

    if (!dfs)
        return ajFalse;

    dba = ensBaseadaptorGetDatabaseadaptor(ba);

    dfa = ensRegistryGetDensityfeatureadaptor(dba);
    dta = ensRegistryGetDensitytypeadaptor(dba);

    sqls = ensDatabaseadaptorSqlstatementNew(dba, statement);

    sqli = ajSqlrowiterNew(sqls);

    while (!ajSqlrowiterDone(sqli))
    {
        identifier = 0;
        srid       = 0;
        srstart    = 0;
        srend      = 0;
        dtid       = 0;
        value      = 0.0F;

        sqlr = ajSqlrowiterGet(sqli);

        ajSqlcolumnToUint(sqlr, &identifier);
        ajSqlcolumnToUint(sqlr, &srid);
        ajSqlcolumnToUint(sqlr, &srstart);
        ajSqlcolumnToUint(sqlr, &srend);
        ajSqlcolumnToUint(sqlr, &dtid);
        ajSqlcolumnToFloat(sqlr, &value);

        ensBaseadaptorRetrieveFeature(ba,
                                      0U,
                                      srid,
                                      srstart,
                                      srend,
                                      srstrand,
                                      am,
                                      slice,
                                      &feature);

        if (!feature)
            continue;

        ensDensitytypeadaptorFetchByIdentifier(dta, dtid, &dt);

        /* Finally, create a new Ensembl Density Feature. */

        df = ensDensityfeatureNewIni(dfa, identifier, feature, dt, value);

        ajListPushAppend(dfs, (void *) df);

        ensDensitytypeDel(&dt);

        ensFeatureDel(&feature);
    }

    ajSqlrowiterDel(&sqli);

    ensDatabaseadaptorSqlstatementDel(dba, &sqls);

    return ajTrue;
}




/* @section constructors ******************************************************
**
** All constructors return a new Ensembl Density Feature Adaptor by pointer.
** It is the responsibility of the user to first destroy any previous
** Density Feature Adaptor. The target pointer does not need to be
** initialised to NULL, but it is good programming practice to do so anyway.
**
** @fdata [EnsPDensityfeatureadaptor]
**
** @nam3rule New Constructor
**
** @argrule New dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
**
** @valrule * [EnsPDensityfeatureadaptor]
** Ensembl Density Feature Adaptor or NULL
**
** @fcategory new
******************************************************************************/




/* @func ensDensityfeatureadaptorNew ******************************************
**
** Default constructor for an Ensembl Density Feature Adaptor.
**
** Ensembl Object Adaptors are singleton objects in the sense that a single
** instance of an Ensembl Object Adaptor connected to a particular database is
** sufficient to instantiate any number of Ensembl Objects from the database.
** Each Ensembl Object will have a weak reference to the Object Adaptor that
** instantiated it. Therefore, Ensembl Object Adaptors should not be
** instantiated directly, but rather obtained from the Ensembl Registry,
** which will in turn call this function if neccessary.
**
** @see ensRegistryGetDatabaseadaptor
** @see ensRegistryGetDensityfeatureadaptor
**
** @cc Bio::EnsEMBL::DBSQL::DensityFeatureAdaptor::new
** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
**
** @return [EnsPDensityfeatureadaptor] Ensembl Density Feature Adaptor or NULL
**
** @release 6.2.0
** @@
******************************************************************************/

EnsPDensityfeatureadaptor ensDensityfeatureadaptorNew(
    EnsPDatabaseadaptor dba)
{
    return ensFeatureadaptorNew(
        dba,
        densityfeatureadaptorKTablenames,
        densityfeatureadaptorKColumnnames,
        (const EnsPBaseadaptorLeftjoin) NULL,
        (const char *) NULL,
        (const char *) NULL,
        &densityfeatureadaptorFetchAllbyStatement,
        (void *(*)(const void *)) NULL,
        (void *(*)(void *)) &ensDensityfeatureNewRef,
        (AjBool (*)(const void *)) NULL,
        (void (*)(void **)) &ensDensityfeatureDel,
        (size_t (*)(const void *)) &ensDensityfeatureCalculateMemsize,
        (EnsPFeature (*)(const void *)) &ensDensityfeatureGetFeature,
        "Density Feature");
}




/* @section destructors *******************************************************
**
** Destruction destroys all internal data structures and frees the memory
** allocated for an Ensembl Density Feature Adaptor object.
**
** @fdata [EnsPDensityfeatureadaptor]
**
** @nam3rule Del Destroy (free) an Ensembl Density Feature Adaptor object
**
** @argrule * Pdfa [EnsPDensityfeatureadaptor*]
** Ensembl Density Feature Adaptor address
**
** @valrule * [void]
**
** @fcategory delete
******************************************************************************/




/* @func ensDensityfeatureadaptorDel ******************************************
**
** Default destructor for an Ensembl Density Feature Adaptor.
**
** Ensembl Object Adaptors are singleton objects that are registered in the
** Ensembl Registry and weakly referenced by Ensembl Objects that have been
** instantiated by it. Therefore, Ensembl Object Adaptors should never be
** destroyed directly. Upon exit, the Ensembl Registry will call this function
** if required.
**
** @param [d] Pdfa [EnsPDensityfeatureadaptor*]
** Ensembl Density Feature Adaptor address
**
** @return [void]
**
** @release 6.2.0
** @@
******************************************************************************/

void ensDensityfeatureadaptorDel(EnsPDensityfeatureadaptor *Pdfa)
{
    ensFeatureadaptorDel(Pdfa);

    return;
}




/* @section member retrieval **************************************************
**
** Functions for returning members of an
** Ensembl Density Feature Adaptor object.
**
** @fdata [EnsPDensityfeatureadaptor]
**
** @nam3rule Get Return Ensembl Density Feature Adaptor attribute(s)
** @nam4rule Baseadaptor Return the Ensembl Base Adaptor
** @nam4rule Databaseadaptor Return the Ensembl Database Adaptor
** @nam4rule Featureadaptor Reutn the Ensembl Feature Adaptor
**
** @argrule * dfa [EnsPDensityfeatureadaptor] Ensembl Density Feature Adaptor
**
** @valrule Baseadaptor [EnsPBaseadaptor]
** Ensembl Base Adaptor or NULL
** @valrule Databaseadaptor [EnsPDatabaseadaptor]
** Ensembl Database Adaptor or NULL
** @valrule Featureadaptor [EnsPFeatureadaptor]
** Ensembl Feature Adaptor or NULL
**
** @fcategory use
******************************************************************************/




/* @func ensDensityfeatureadaptorGetBaseadaptor *******************************
**
** Get the Ensembl Base Adaptor member of an
** Ensembl Density Feature Adaptor.
**
** @param [u] dfa [EnsPDensityfeatureadaptor] Ensembl Density Feature Adaptor
**
** @return [EnsPBaseadaptor] Ensembl Base Adaptor or NULL
**
** @release 6.4.0
** @@
******************************************************************************/

EnsPBaseadaptor ensDensityfeatureadaptorGetBaseadaptor(
    EnsPDensityfeatureadaptor dfa)
{
    return ensFeatureadaptorGetBaseadaptor(
        ensDensityfeatureadaptorGetFeatureadaptor(dfa));
}




/* @func ensDensityfeatureadaptorGetDatabaseadaptor ***************************
**
** Get the Ensembl Database Adaptor member of an
** Ensembl Density Feature Adaptor.
**
** @param [u] dfa [EnsPDensityfeatureadaptor] Ensembl Density Feature Adaptor
**
** @return [EnsPDatabaseadaptor] Ensembl Database Adaptor or NULL
**
** @release 6.4.0
** @@
******************************************************************************/

EnsPDatabaseadaptor ensDensityfeatureadaptorGetDatabaseadaptor(
    EnsPDensityfeatureadaptor dfa)
{
    return ensFeatureadaptorGetDatabaseadaptor(
        ensDensityfeatureadaptorGetFeatureadaptor(dfa));
}




/* @func ensDensityfeatureadaptorGetFeatureadaptor ****************************
**
** Get the Ensembl Feature Adaptor member of an
** Ensembl Density Feature Adaptor.
**
** @param [u] dfa [EnsPDensityfeatureadaptor] Ensembl Density Feature Adaptor
**
** @return [EnsPFeatureadaptor] Ensembl Feature Adaptor or NULL
**
** @release 6.5.0
** @@
******************************************************************************/

EnsPFeatureadaptor ensDensityfeatureadaptorGetFeatureadaptor(
    EnsPDensityfeatureadaptor dfa)
{
    return dfa;
}




/* @section object retrieval **************************************************
**
** Functions for fetching Ensembl Density Feature objects from an
** Ensembl SQL database.
**
** @fdata [EnsPDensityfeatureadaptor]
**
** @nam3rule Fetch Fetch Ensembl Density Feature object(s)
** @nam4rule All Fetch all Ensembl Density Feature objects
** @nam4rule Allby Fetch all Ensembl Density Feature objects
**                 matching a criterion
** @nam5rule Slice Fetch all by an Ensembl Slice
** @nam4rule By Fetch one Ensembl Density Feature object matching a criterion
** @nam5rule ByIdentifier Fetch by an SQL database-internal identifier
**
** @argrule * dfa [EnsPDensityfeatureadaptor] Ensembl Density Feature Adaptor
** @argrule All dfs [AjPList] AJAX List of Ensembl Density Feature objects
** @argrule AllbySlice slice [EnsPSlice] Ensembl Slice
** @argrule AllbySlice anname [const AjPStr] Ensembl Analysis name
** @argrule AllbySlice blocks [ajuint] The number of features
** @argrule AllbySlice interpolate [AjBool] A flag indicating interpolation
** @argrule AllbySlice maxratio [float] The maximum ratio
** @argrule AllbySlice dfs [AjPList] AJAX List of Ensembl Density Feature
**                                   objects
** @argrule ByIdentifier identifier [ajuint] SQL database-internal identifier
** @argrule ByIdentifier Pdf [EnsPDensityfeature*] Ensembl Density Feature
**                                                 address
**
** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
**
** @fcategory use
******************************************************************************/




/* @func ensDensityfeatureadaptorFetchAllbySlice ******************************
**
** Fetch all Ensembl Density Feature objects on an Ensembl Slice.
**
** @cc Bio::EnsEMBL::DBSQL::BaseFeatureAdaptor::fetch_all_by_Slice
** @param [u] dfa [EnsPDensityfeatureadaptor] Ensembl Density Feature Adaptor
** @param [u] slice [EnsPSlice] Ensembl Slice
** @param [r] anname [const AjPStr] Ensembl Analysis name
** @param [r] blocks [ajuint] The number of Ensembl Density Feature objects
**     that are desired. The ratio between the size of
**     features and the size of the features in the database will be
**     used to determine, which database features will be used.
** @param [r] interpolate [AjBool] A flag indicating
**     whether the features in the database should be interpolated to
**     fit them to the requested number of features. If true the
**     features will be interpolated to provide $num_blocks features.
**     This will not guarantee that exactly $num_blocks features are
**     returned due to rounding etc. but it will be close.
** @param [r] maxratio [float] The maximum ratio between the size of the
**     requested features (as determined by blocks) and the actual
**     size of the features in the database.  If this value is exceeded
**     then an empty list will be returned.  This can be used to
**     prevent excessive interpolation of the database values.
** @param [u] dfs [AjPList] AJAX List of Ensembl Density Feature objects
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.4.0
** @@
******************************************************************************/

AjBool ensDensityfeatureadaptorFetchAllbySlice(
    EnsPDensityfeatureadaptor dfa,
    EnsPSlice slice,
    const AjPStr anname,
    ajuint blocks,
    AjBool interpolate,
    float maxratio,
    AjPList dfs)
{
    double portion = 0.0;
    double ratio   = 0.0;
    ajint  slctmp  = 0;
    double ceitmp  = 0.0;
    float value    = 0.0F;

    register ajuint i = 0U;

    /* Block start and end */
    ajint bstart   = 0;
    ajint bend     = 0;
    ajuint blength = 0U;

    /* Feature start and end */
    ajint fstart = 0;
    ajint fend   = 0;

    ajint bsize = 0;

    AjBool debug = AJFALSE;

    AjPList dts       = NULL;
    AjPList dlvs      = NULL;
    AjPList dtrs      = NULL;
    AjPList dfeatures = NULL;

    AjPStr constraint = NULL;
    AjPStr names      = NULL;

    EnsPAnalysis analysis = NULL;

    EnsPDatabaseadaptor dba = NULL;

    EnsPDensityfeature df    = NULL;
    EnsPDensityfeature newdf = NULL;

    EnsPDensitytype dt         = NULL;
    EnsPDensitytype newdt      = NULL;
    EnsPDensitytypeadaptor dta = NULL;

    EnsPFeature feature    = NULL;
    EnsPFeature newfeature = NULL;

    DensityPLengthValue dlv = NULL;

    DensityPTypeRatio dtr = NULL;

    debug = ajDebugTest("ensDensityfeatureadaptorFetchAllbySlice");

    if (debug)
        ajDebug("ensDensityfeatureadaptorFetchAllbySlice\n"
                "  dfa %p\n"
                "  slice %p\n"
                "  anname '%S'\n"
                "  blocks %u\n"
                "  interpolate '%B'\n"
                "  maxratio %f\n"
                "  dfs %p\n",
                dfa,
                slice,
                anname,
                blocks,
                interpolate,
                maxratio,
                dfs);

    if (!dfa)
        return ajFalse;

    if (!slice)
        return ajFalse;

    if (!dfs)
        return ajFalse;

    if (!blocks)
        blocks = 50U;

    /*
    ** Get all of the Density Types and choose the one with the
    ** block size closest to our desired block size.
    */

    dba = ensDensityfeatureadaptorGetDatabaseadaptor(dfa);

    dta = ensRegistryGetDensitytypeadaptor(dba);

    dts = ajListNew();

    ensDensitytypeadaptorFetchAllbyAnalysisname(dta, anname, dts);

    if (!ajListGetLength(dts))
    {
        ensDensitytypeadaptorFetchAll(dta, dts);

        names = ajStrNew();

        while (ajListPop(dts, (void **) &dt))
        {
            analysis = ensDensitytypeGetAnalysis(dt);

            names = ajFmtPrintAppS(&names, "'%S' ",
                                   ensAnalysisGetName(analysis));

            ensDensitytypeDel(&dt);
        }

        ajWarn("ensDensityfeatureadaptorFetchAllbySlice got an invalid "
               "Ensembl Analysis name '%S' only the following are allowed %S.",
               anname,
               names);

        ajStrDel(&names);

        ajListFree(&dts);

        return ajFalse;
    }

    /*
    ** The window size is the length of the Ensembl Slice
    ** divided by the number of requested blocks.
    ** Need to go through some horrendous casting to
    ** satisfy really pedantic compilers
    */

    slctmp = (ajint) ensSliceCalculateLength(slice);
    ceitmp = ceil((double) slctmp / (double) blocks);

    bsize = (ajint) ceitmp;

    dtrs = ajListNew();

    while (ajListPop(dts, (void **) &dt))
    {
        if (ensDensitytypeGetSize(dt) > 0)
            ratio = (double) bsize /
                (double) (ajint) ensDensitytypeGetSize(dt);
        else
        {
            /*
            ** This is only valid if the requested Sequence Region is the one
            ** the Feature objects are stored on. Please use sensibly or find a
            ** better implementation.
            */

            ratio = (double) bsize /
                (ensSliceGetSeqregionLength(slice) /
                 (double) (ajint) ensDensitytypeGetFeatures(dt));
        }

        /*
        ** We prefer to use a block size that is smaller than the
        ** required one, which gives better results on interpolation.
        ** Give larger bits a disadvantage and make them comparable.
        */

        if (ratio < 1.0)
            ratio = 5.0 / ratio;

        AJNEW0(dtr);

        dtr->Densitytype = dt;

        dtr->Ratio = (float) ratio;

        ajListPushAppend(dtrs, (void *) dtr);
    }

    ajListFree(&dts);

    /*
    ** Sort the AJAX List of Ensembl Density Types by their ratio
    ** and get the best one.
    */

    ajListSort(dtrs, &listDensitytyperatioCompareRatioAscending);

    ajListPeekFirst(dtrs, (void **) &dtr);

    if (debug)
    {
        if (dtr)
            ajDebug("ensDensityfeatureadaptorFetchAllbySlice got ratio %f "
                    "and maxratio %f.\n", dtr->Ratio, maxratio);
        else
            ajDebug("ensDensityfeatureadaptorFetchAllbySlice got no ratio.\n");
    }

    /*
    ** The ratio was not good enough, or the Ensembl Analysis name was not
    ** in the 'density_type' table, return an empty list.
    */

    if ((!dtr) || (dtr->Ratio > maxratio))
    {
        while (ajListPop(dtrs, (void **) &dtr))
        {
            ensDensitytypeDel(&dtr->Densitytype);

            AJFREE(dtr);
        }

        ajListFree(&dtrs);

        return ajTrue;
    }

    constraint = ajFmtStr("density_feature.density_type_id = %u",
                          ensDensitytypeGetIdentifier(dtr->Densitytype));

    ensFeatureadaptorFetchAllbySlice(
        ensDensityfeatureadaptorGetFeatureadaptor(dfa),
        slice,
        constraint,
        (const AjPStr) NULL,
        dfs);

    ajStrDel(&constraint);

    if (!interpolate)
    {
        while (ajListPop(dtrs, (void **) &dtr))
        {
            ensDensitytypeDel(&dtr->Densitytype);

            AJFREE(dtr);
        }

        ajListFree(&dtrs);

        return ajTrue;
    }

    /*
    ** Interpolate the Density Feature objects into new Density Feature objects
    ** of a different size, but move them to a new AJAX List first. Sort
    ** Ensembl Density Feature objects by ascening start position.
    */

    dfeatures = ajListNew();

    while (ajListPop(dfs, (void **) &df))
        ajListPushAppend(dfeatures, (void *) df);

    ensListDensityfeatureSortStartAscending(dfeatures);

    /* Resize the Feature objects that were returned. */

    bstart = 1;

    bend = bstart + bsize - 1;

    /*
    ** Create a new Ensembl Density Type for the interpolated
    ** Ensembl Density Feature objects that are not stored in the database.
    */

    newdt = ensDensitytypeNewCpy(dtr->Densitytype);

    ensDensitytypeSetIdentifier(newdt, 0);

    ensDensitytypeSetSize(newdt, bsize);

    dlvs = ajListNew();

    while (bstart < (ajint) ensSliceCalculateLength(slice))
    {
        value = 0.0F;

        if (debug)
            ajDebug("ensDensityfeatureadaptorFetchAllbySlice "
                    "bstart %d bend %d value %f\n",
                    bstart, bend, value);

        /*
        ** Construct a new Ensembl Density Feature using all the old
        ** Ensembl Density Feature objects that overlapped.
        */

        while (ajListPeekNumber(dfeatures, i, (void **) &df) &&
               (feature = ensDensityfeatureGetFeature(df)) &&
               (ensFeatureGetStart(feature) < bend))
        {
            /*
            ** What portion of this Feature is used
            ** to construct the new block?
            */

            /* Constrain the Feature start to no less than the block start. */

            fstart = (ensFeatureGetStart(feature) < bstart)
                ? bstart : ensFeatureGetStart(feature);

            /* Constrain the Feature end to no more than the block end. */

            fend = (ensFeatureGetEnd(feature) > bend)
                ? bend : ensFeatureGetEnd(feature);

            /* Constrain the Feature end to no more than the Slice length. */

            fend = (fend > (ajint) ensSliceCalculateLength(slice))
                ? (ajint) ensSliceCalculateLength(slice) : fend;

            if (debug)
                ajDebug("ensDensityfeatureadaptorFetchAllbySlice "
                        "bstart %d bend %d fstart %d fend %d id %u value %f\n",
                        bstart, bend, fstart, fend,
                        ensDensityfeatureGetIdentifier(df),
                        ensDensityfeatureGetValue(df));

            switch (ensDensitytypeGetType(newdt))
            {
                case ensEDensitytypeTypeSum:

                    portion = (fend - fstart + 1) /
                        ensFeatureCalculateLength(feature);

                    /*
                    ** Take a percentage of density value, depending on
                    ** how much of the Ensembl Density Feature was overlapped.
                    */

                    value += (float) (portion *
                                      ensDensityfeatureGetValue(df));

                    break;

                case ensEDensitytypeTypeRatio:

                    /*
                    ** Maintain a running total of the length used from each
                    ** Ensembl Density Feature and its value.
                    */

                    AJNEW0(dlv);

                    dlv->Length = fend - fstart + 1;

                    dlv->Value = ensDensityfeatureGetValue(df);

                    ajListPushAppend(dlvs, (void *) dlv);

                    break;

                default:

                    ajWarn("ensDensityfeatureadaptorFetchAllbySlice got an "
                           "Ensembl Density Type with unknown type %d.",
                           ensDensitytypeGetType(newdt));
            }

            /*
            ** Do not look at the next Density Feature,
            ** if only a part of this one has been used.
            */

            if (fend < ensFeatureGetEnd(feature))
                break;

            i++;
        }

        if (ensDensitytypeGetType(newdt) == ensEDensitytypeTypeRatio)
        {
            /*
            ** Take a weighted average of all the density values
            ** of the Feature objects used to construct this one.
            */

            blength = bend - bstart + 1;

            while (ajListPop(dlvs, (void **) &dlv))
            {
                if (blength > 0)
                    value += dlv->Value * (float) dlv->Length /
                        (float) blength;

                if (debug)
                    ajDebug("ensDensityfeatureadaptorFetchAllbySlice "
                            "bstart %d bend %d blength %u "
                            "DLV Length %u DLV Value %f "
                            "value %f \n",
                            bstart, bend, blength,
                            dlv->Length, dlv->Value,
                            value);

                AJFREE(dlv);
            }
        }

        /*
        ** Interpolated Ensembl Density Feature objects are not stored in the
        ** database so they do not need an identifier or
        ** Ensembl Density Feature Adaptor.
        */

        newfeature = ensFeatureNewCpy(feature);

        ensFeatureMove(newfeature, bstart, bend, 0);

        newdf = ensDensityfeatureNewIni((EnsPDensityfeatureadaptor) NULL,
                                        0,
                                        newfeature,
                                        newdt,
                                        value);

        ajListPushAppend(dfs, (void *) newdf);

        ensFeatureDel(&newfeature);

        /* Clear the AJAX List of remaining density length values. */

        while (ajListPop(dlvs, (void **) &dlv))
            AJFREE(dlv);

        /* Advance one block. */

        bstart = bend + 1;

        bend  += bsize;
    }

    ajListFree(&dlvs);

    ensDensitytypeDel(&newdt);

    /* Clear the AJAX List of intermediary Ensembl Density Feature objects. */

    while (ajListPop(dfeatures, (void **) &df))
        ensDensityfeatureDel(&df);

    ajListFree(&dfeatures);

    /* Clear the AJAX List of density type ratios. */

    while (ajListPop(dtrs, (void **) &dtr))
    {
        ensDensitytypeDel(&dtr->Densitytype);

        AJFREE(dtr);
    }

    ajListFree(&dtrs);

    return ajTrue;
}