/* @source ensintron **********************************************************
**
** Ensembl Intron functions
**
** @author Copyright (C) 1999 Ensembl Developers
** @author Copyright (C) 2006 Michael K. Schuster
** @version $Revision: 1.28 $
** @modified 2009 by Alan Bleasby for incorporation into EMBOSS core
** @modified $Date: 2013/02/17 13:07:37 $ 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 "ensintron.h"
#include "ensexon.h"
#include "enstranscript.h"




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




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




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




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

/* @conststatic intronsupportingevidenceKType *********************************
**
** The Ensembl Intron Supporting Evidence type member 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
** EnsEIntronsupportingevidenceType and the
** 'intron_supporting_evidence.score_type' field.
**
******************************************************************************/

static const char *const intronsupportingevidenceKType[] =
{
    "",
    "NONE",
    "DEPTH",
    (const char *) NULL
};




/* @conststatic intronsupportingevidenceadaptorKTablenames ********************
**
** Array of Ensembl Intron Supporting Evidence Adaptor SQL table names
**
******************************************************************************/

static const char *const intronsupportingevidenceadaptorKTablenames[] =
{
    "intron_supporting_evidence",
    (const char *) NULL
};




/* @conststatic intronsupportingevidenceadaptorKColumnnames *******************
**
** Array of Ensembl Intron Supporting Evidence Adaptor SQL column names
**
******************************************************************************/

static const char *const intronsupportingevidenceadaptorKColumnnames[] =
{
    "intron_supporting_evidence.intron_supporting_evidence_id",
    "intron_supporting_evidence.seq_region_id",
    "intron_supporting_evidence.seq_region_start",
    "intron_supporting_evidence.seq_region_end",
    "intron_supporting_evidence.seq_region_strand",
    "intron_supporting_evidence.analysis_id",
    "intron_supporting_evidence.hit_name",
    "intron_supporting_evidence.score",
    "intron_supporting_evidence.score_type",
    "intron_supporting_evidence.is_splice_canonical",
    (const char *) NULL
};




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




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

static EnsPIntron intronNewCpyFeatures(EnsPIntron intron);

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




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




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




/* @datasection [EnsPIntron] Ensembl Intron ***********************************
**
** @nam2rule Intron Functions for manipulating Ensembl Intron objects
**
** @cc Bio::EnsEMBL::Intron
** @cc CVS Revision: 1.22
** @cc CVS Tag: branch-ensembl-68
**
******************************************************************************/




/* @section constructors ******************************************************
**
** All constructors return a new Ensembl Intron by pointer.
** It is the responsibility of the user to first destroy any previous
** Intron. The target pointer does not need to be initialised to
** NULL, but it is good programming practice to do so anyway.
**
** @fdata [EnsPIntron]
**
** @nam3rule New Constructor
** @nam4rule Cpy Constructor with existing object
** @nam4rule Ini Constructor with initial values
** @nam4rule Ref Constructor by incrementing the use counter
**
** @argrule Cpy intron [const EnsPIntron] Ensembl Intron
** @argrule Ini exon1 [EnsPExon] Ensembl Exon 1
** @argrule Ini exon2 [EnsPExon] Ensembl Exon 2
** @argrule Ini analysis [EnsPAnalysis] Ensembl Analysis
** @argrule Ref intron [EnsPIntron] Ensembl Intron
**
** @valrule * [EnsPIntron] Ensembl Intron or NULL
**
** @fcategory new
******************************************************************************/




/* @func ensIntronNewCpy ******************************************************
**
** Object-based constructor function, which returns an independent object.
**
** @param [r] intron [const EnsPIntron] Ensembl Intron
**
** @return [EnsPIntron] Ensembl Intron or NULL
**
** @release 6.4.0
** @@
******************************************************************************/

EnsPIntron ensIntronNewCpy(const EnsPIntron intron)
{
    EnsPIntron pthis = NULL;

    if (!intron)
        return NULL;

    AJNEW0(pthis);

    pthis->Feature      = ensFeatureNewRef(intron->Feature);
    pthis->PreviousExon = ensExonNewRef(intron->PreviousExon);
    pthis->NextExon     = ensExonNewRef(intron->NextExon);
    pthis->Use          = 1U;

    return pthis;
}




/* @func ensIntronNewIni ******************************************************
**
** Default constructor for an Ensembl Intron with initial values.
**
** @cc Bio::EnsEMBL::Intron::new
** @param [u] exon1 [EnsPExon] Ensembl Exon 1
** @param [u] exon2 [EnsPExon] Ensembl Exon 2
** @param [uN] analysis [EnsPAnalysis] Ensembl Analysis
**
** @return [EnsPIntron] Ensembl Intron or NULL
**
** @release 6.4.0
** @@
******************************************************************************/

EnsPIntron ensIntronNewIni(EnsPExon exon1,
                           EnsPExon exon2,
                           EnsPAnalysis analysis)
{
    ajint strand = 0;

    ajuint start = 0U;
    ajuint end   = 0U;

    AjPStr seqname1 = NULL;
    AjPStr seqname2 = NULL;

    EnsPFeature feature  = NULL;
    EnsPFeature feature1 = NULL;
    EnsPFeature feature2 = NULL;

    EnsPIntron intron = NULL;

    EnsPSlice slice1 = NULL;
    EnsPSlice slice2 = NULL;

    if (ajDebugTest("ensIntronNewIni"))
    {
        ajDebug("ensIntronNewIni\n"
                "  exon1 %p\n"
                "  exon2 %p\n"
                "  analysis %p\n",
                exon1,
                exon2,
                analysis);

        ensExonTrace(exon1, 1);
        ensExonTrace(exon2, 1);
    }

    if (!exon1)
        return NULL;

    if (!exon2)
        return NULL;

    feature1 = ensExonGetFeature(exon1);
    feature2 = ensExonGetFeature(exon2);

    slice1 = ensFeatureGetSlice(feature1);
    slice2 = ensFeatureGetSlice(feature2);

    seqname1 = ensFeatureGetSequencename(feature1);
    seqname2 = ensFeatureGetSequencename(feature2);

    /* Both Exon objects have to be on the same Slice or sequence name. */

    if (!((slice1 && slice2) || (seqname1 && seqname2)))
    {
        ajDebug("ensIntronNewIni got Ensembl Exon objects on both, an "
                "Ensembl Slice and sequence name.\n");

        return NULL;
    }

    if (slice1 && slice2 && (!ensSliceMatch(slice1, slice2)))
    {
        ajDebug("ensIntronNewIni got Ensembl Exon objects on different "
                "Ensembl Slice objects.\n");

        return NULL;
    }

    if (seqname1 && seqname2 && (!ajStrMatchCaseS(seqname1, seqname2)))
    {
        ajDebug("ensIntronNewIni got Ensembl Exon objects on different "
                "sequence names.\n");

        return NULL;
    }

    if (ensFeatureGetStrand(feature1) != ensFeatureGetStrand(feature2))
    {
        ajDebug("ensIntronNewIni got Ensembl Exon objects on different "
                "strands.\n");

        return NULL;
    }

    if (ensFeatureGetStrand(feature1) >= 0)
    {
        start = ensFeatureGetEnd(feature1)   + 1;
        end   = ensFeatureGetStart(feature2) - 1;
    }
    else
    {
        start = ensFeatureGetEnd(feature2)   + 1;
        end   = ensFeatureGetStart(feature1) - 1;
    }

    if (start > (end + 1))
    {
        ajDebug("ensIntronNewIni requires that the start coordinate %u "
                "is less than the end coordinate %u + 1 ", start, end);

        return NULL;
    }

    strand = ensFeatureGetStrand(feature1);

    if (slice1)
        feature = ensFeatureNewIniS(analysis,
                                    slice1,
                                    start,
                                    end,
                                    strand);

    if (seqname1)
        feature = ensFeatureNewIniN(analysis,
                                    seqname1,
                                    start,
                                    end,
                                    strand);

    if (feature)
    {
        AJNEW0(intron);

        intron->Feature      = feature;
        intron->PreviousExon = ensExonNewRef(exon1);
        intron->NextExon     = ensExonNewRef(exon2);
        intron->Use          = 1U;
    }
    else
        ajDebug("ensIntronNewIni could not create an Ensembl Feature.\n");

    return intron;
}




/* @func ensIntronNewRef ******************************************************
**
** Ensembl Object referencing function, which returns a pointer to the
** Ensembl Object passed in and increases its reference count.
**
** @param [u] intron [EnsPIntron] Ensembl Intron
**
** @return [EnsPIntron] Ensembl Intron or NULL
**
** @release 6.2.0
** @@
******************************************************************************/

EnsPIntron ensIntronNewRef(EnsPIntron intron)
{
    if (!intron)
        return NULL;

    intron->Use++;

    return intron;
}




/* @funcstatic intronNewCpyFeatures *******************************************
**
** Returns a new copy of an Ensembl Intron, but in addition to the shallow
** copy provided by ensIntronNewCpy, also copies all Ensembl Intron-
** internal Ensembl Objects based on the Ensembl Feature class. This is useful
** in preparation of ensIntronTransform and ensIntronTransfer, which
** return an independent Ensembl Intron object and therefore, require
** independent mapping of all internal Feature objects to the new
** Ensembl Coordinate System or Ensembl Slice.
**
** @param [u] intron [EnsPIntron] Ensembl Intron
**
** @return [EnsPIntron] Ensembl Intron or NULL
**
** @release 6.5.0
** @@
******************************************************************************/

static EnsPIntron intronNewCpyFeatures(EnsPIntron intron)
{
    EnsPExon newexon = NULL;

    EnsPIntron newintron = NULL;

    if (!intron)
        return NULL;

    newintron = ensIntronNewCpy(intron);

    if (!newintron)
        return NULL;

    newexon = ensExonNewCpy(intron->PreviousExon);
    ensExonDel(&intron->PreviousExon);
    intron->PreviousExon = newexon;

    newexon = ensExonNewCpy(intron->NextExon);
    ensExonDel(&intron->NextExon);
    intron->NextExon = newexon;

    return newintron;
}




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




/* @func ensIntronDel *********************************************************
**
** Default destructor for an Ensembl Intron.
**
** @param [d] Pintron [EnsPIntron*] Ensembl Intron address
**
** @return [void]
**
** @release 6.2.0
** @@
******************************************************************************/

void ensIntronDel(EnsPIntron *Pintron)
{
    EnsPIntron pthis = NULL;

    if (!Pintron)
        return;

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

        ensIntronTrace(*Pintron, 1);
    }
#endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */

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

        return;
    }

    ensFeatureDel(&pthis->Feature);

    ensExonDel(&pthis->PreviousExon);
    ensExonDel(&pthis->NextExon);

    ajMemFree((void **) Pintron);

    return;
}




/* @section member retrieval **************************************************
**
** Functions for returning members of an Ensembl Intron object.
**
** @fdata [EnsPIntron]
**
** @nam3rule Get Return Ensembl Intron attribute(s)
** @nam4rule Feature Return the Ensembl Feature
** @nam4rule Previousexon Return the previous Ensembl Exon
** @nam4rule Nextexon Return the next Ensembl Exon
**
** @argrule * intron [const EnsPIntron] Intron
**
** @valrule Feature [EnsPFeature] Ensembl Feature or NULL
** @valrule Nextexon [EnsPExon] Ensembl Exon or NULL
** @valrule Previousexon [EnsPExon] Ensembl Exon or NULL
**
** @fcategory use
******************************************************************************/




/* @func ensIntronGetFeature **************************************************
**
** Get the Ensembl Feature member of an Ensembl Intron.
**
** @cc Bio::EnsEMBL::Feature
** @param [r] intron [const EnsPIntron] Ensembl Intron
**
** @return [EnsPFeature] Ensembl Feature or NULL
**
** @release 6.2.0
** @@
******************************************************************************/

EnsPFeature ensIntronGetFeature(const EnsPIntron intron)
{
    return (intron) ? intron->Feature : NULL;
}




/* @func ensIntronGetNextexon *************************************************
**
** Get the next Ensembl Exon member of an Ensembl Intron.
**
** @cc Bio::EnsEMBL::Intron::next_Exon
** @param [r] intron [const EnsPIntron] Ensembl Intron
**
** @return [EnsPExon] Ensembl Exon or NULL
**
** @release 6.2.0
** @@
******************************************************************************/

EnsPExon ensIntronGetNextexon(const EnsPIntron intron)
{
    return (intron) ? intron->NextExon : NULL;
}




/* @func ensIntronGetPreviousexon *********************************************
**
** Get the previous Ensembl Exon member of an Ensembl Intron.
**
** @cc Bio::EnsEMBL::Intron::prev_Exon
** @param [r] intron [const EnsPIntron] Ensembl Intron
**
** @return [EnsPExon] Ensembl Exon or NULL
**
** @release 6.2.0
** @@
******************************************************************************/

EnsPExon ensIntronGetPreviousexon(const EnsPIntron intron)
{
    return (intron) ? intron->PreviousExon : NULL;
}




/* @section member assignment *************************************************
**
** Functions for assigning members of an Ensembl Intron object.
**
** @fdata [EnsPIntron]
**
** @nam3rule Set Set one member of an Ensembl Intron
** @nam4rule Feature Set the Ensembl Feature
** @nam4rule Nextexon Set the next Ensembl Exon
** @nam4rule Previousexon Set the previous Ensembl Exon
**
** @argrule * intron [EnsPIntron] Ensembl Intron
**
** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
** @argrule Feature feature [EnsPFeature] Ensembl Feature
** @argrule Nextexon exon [EnsPExon] Next Ensembl Exon
** @argrule Previousexon exon [EnsPExon] Previous Ensembl Exon
**
** @fcategory modify
******************************************************************************/





/* @func ensIntronSetFeature **************************************************
**
** Set the Ensembl Feature member of an Ensembl Intron.
**
** @cc Bio::EnsEMBL::Feature
** @param [u] intron [EnsPIntron] Ensembl Intron
** @param [u] feature [EnsPFeature] Ensembl Feature
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.5.0
** @@
******************************************************************************/

AjBool ensIntronSetFeature(EnsPIntron intron,
                           EnsPFeature feature)
{
    EnsPExon newexon = NULL;

    EnsPSlice slice = NULL;

    if (!intron)
        return ajFalse;

    /* Replace the current Feature. */

    ensFeatureDel(&intron->Feature);

    if (feature)
    {
        intron->Feature = ensFeatureNewRef(feature);

        slice = ensFeatureGetSlice(intron->Feature);

        /*
        ** Transfer Ensembl Exon objects onto the new Ensembl Slice
        ** linked to this Ensembl Feature.
        */

        newexon = ensExonTransfer(intron->PreviousExon, slice);
        ensExonDel(&intron->PreviousExon);
        intron->PreviousExon = newexon;

        newexon = ensExonTransfer(intron->NextExon, slice);
        ensExonDel(&intron->NextExon);
        intron->NextExon = newexon;
    }

    return ajTrue;
}




/* @func ensIntronSetNextexon *************************************************
**
** Set the next Ensembl Exon member of an Ensembl Intron.
**
** @cc Bio::EnsEMBL::Intron::next_Exon
** @param [u] intron [EnsPIntron] Ensembl Intron
** @param [u] exon [EnsPExon] Ensembl Exon
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.5.0
** @@
** NOTE: The Perl API has no set method and does not transfer the Ensembl Exon
** object onto the Ensembl Slice of the Ensembl Intron object.
******************************************************************************/

AjBool ensIntronSetNextexon(EnsPIntron intron,
                            EnsPExon exon)
{
    if (!intron)
        return ajFalse;

    ensExonDel(&intron->NextExon);

    intron->NextExon = ensExonTransfer(
        exon,
        ensFeatureGetSlice(intron->Feature));

    if (!intron->NextExon)
        ajWarn("ensIntronSetNextexon could not transfer "
               "Ensembl Exon %u onto the "
               "Ensembl Slice of this "
               "Ensembl Intron.\n",
               ensExonGetIdentifier(exon));

    return ajTrue;
}




/* @func ensIntronSetPreviousexon *********************************************
**
** Set the previous Ensembl Exon member of an Ensembl Intron.
**
** @cc Bio::EnsEMBL::Intron::prev_Exon
** @param [u] intron [EnsPIntron] Ensembl Intron
** @param [u] exon [EnsPExon] Ensembl Exon
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.5.0
** @@
** NOTE: The Perl API has no set method and does not transfer the Ensembl Exon
** object onto the Ensembl Slice of the Ensembl Intron object.
******************************************************************************/

AjBool ensIntronSetPreviousexon(EnsPIntron intron,
                                EnsPExon exon)
{
    if (!intron)
        return ajFalse;

    ensExonDel(&intron->PreviousExon);

    intron->PreviousExon = ensExonTransfer(
        exon,
        ensFeatureGetSlice(intron->Feature));

    if (!intron->NextExon)
        ajWarn("ensIntronSetPreviousexon could not transfer "
               "Ensembl Exon '%u' onto the "
               "Ensembl Slice of this "
               "Ensembl Intron.\n",
               ensExonGetIdentifier(exon));

    return ajTrue;
}




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




/* @func ensIntronTrace *******************************************************
**
** Trace an Ensembl Intron.
**
** @param [r] intron [const EnsPIntron] Ensembl Intron
** @param [r] level [ajuint] Indentation level
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.2.0
** @@
******************************************************************************/

AjBool ensIntronTrace(const EnsPIntron intron, ajuint level)
{
    AjPStr indent = NULL;

    if (!intron)
        return ajFalse;

    indent = ajStrNew();

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

    ajDebug("%SensIntronTrace %p\n"
            "%S  Feature %p\n"
            "%S  PreviousExon %p\n"
            "%S  NextExon %p\n"
            "%S  Use %u\n",
            indent, intron,
            indent, intron->Feature,
            indent, intron->PreviousExon,
            indent, intron->NextExon,
            indent, intron->Use);

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

    ensExonTrace(intron->PreviousExon, level + 1);
    ensExonTrace(intron->NextExon, level + 1);

    ajStrDel(&indent);

    return ajTrue;
}




/* @section calculate *********************************************************
**
** Functions for calculating information from an Ensembl Intron object.
**
** @fdata [EnsPIntron]
**
** @nam3rule Calculate Calculate Ensembl Intron information
** @nam4rule Length  Calculate the length
** @nam4rule Memsize Calculate the memory size in bytes
**
** @argrule * intron [const EnsPIntron] Ensembl Intron
**
** @valrule Length [ajuint] Length or 0U
** @valrule Memsize [size_t] Memory size in bytes or 0
**
** @fcategory misc
******************************************************************************/




/* @func ensIntronCalculateLength *********************************************
**
** Calculate the length of an Ensembl Intron.
**
** @cc Bio::EnsEMBL::Intron::length
** @param [r] intron [const EnsPIntron] Ensembl Intron
**
** @return [ajuint] Length or 0U
**
** @release 6.4.0
** @@
** NOTE: The Bio::EnsEMBL::Intron::length method seems to override
** Bio::EnsEMBL::Feature::length to allow for zero-length introns.
******************************************************************************/

ajuint ensIntronCalculateLength(const EnsPIntron intron)
{
    if (!intron)
        return 0U;

    return ensFeatureGetEnd(intron->Feature)
        - ensFeatureGetStart(intron->Feature)
        + 1U;
}




/* @func ensIntronCalculateMemsize ********************************************
**
** Calculate the memory size in bytes of an Ensembl Intron.
**
** @param [r] intron [const EnsPIntron] Ensembl Intron
**
** @return [size_t] Memory size in bytes or 0
**
** @release 6.4.0
** @@
******************************************************************************/

size_t ensIntronCalculateMemsize(const EnsPIntron intron)
{
    size_t size = 0;

    if (!intron)
        return 0;

    size += sizeof (EnsOIntron);

    size += ensFeatureCalculateMemsize(intron->Feature);

    size += ensExonCalculateMemsize(intron->PreviousExon);
    size += ensExonCalculateMemsize(intron->NextExon);

    return size;
}




/* @section fetch *************************************************************
**
** Functions for fetching information from an Ensembl Intron object.
**
** @fdata [EnsPIntron]
**
** @nam3rule Fetch Fetch Ensembl Intron information
** @nam4rule All   Fetch all Ensembl Intron information
** @nam4rule Splicesequences
** Fetch splice site sequences
**
** @argrule * intron [const EnsPIntron] Ensembl Intron
** @argrule Splicesequences Pdonor [AjPStr*]
** AJAX String (splice donor sequence) address
** @argrule Splicesequences Pacceptor [AjPStr*]
** AJAX String (splice acceptor sequence) address
**
** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
**
** @fcategory misc
******************************************************************************/




/* @func ensIntronFetchSplicesequences ****************************************
**
** Fetch splice site sequences of an Ensembl Intron.
**
** The caller is responsible for deleting the
** AJAX String objects.
**
** @cc Bio::EnsEMBL::Intron::splice_seq
** @param [r] intron [const EnsPIntron] Ensembl Intron
** @param [wP] Pdonor [AjPStr*]
** AJAX String (splice donor sequence) address
** @param [wP] Pacceptor [AjPStr*]
** AJAX String (splice acceptor sequence) address
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.5.0
** @@
******************************************************************************/

AjBool ensIntronFetchSplicesequences(const EnsPIntron intron,
                                     AjPStr *Pdonor,
                                     AjPStr *Pacceptor)
{
    ajuint length = 0U;

    AjBool result = AJFALSE;

    EnsPSlice      slice = NULL;
    EnsPSliceadaptor sla = NULL;

    if (!intron)
        return ajFalse;

    if (!*Pdonor)
        return ajFalse;

    if (!*Pacceptor)
        return ajFalse;

    if (*Pdonor)
        ajStrAssignClear(Pdonor);

    if (*Pacceptor)
        ajStrAssignClear(Pacceptor);

    sla = ensRegistryGetSliceadaptor(
        ensExonadaptorGetDatabaseadaptor(
            ensExonGetAdaptor(intron->PreviousExon)));

    result = ensSliceadaptorFetchByFeature(sla,
                                           intron->Feature,
                                           0,
                                           &slice);

    if (!result)
        return result;

    length = ensSliceCalculateLength(slice);

    result = ensSliceFetchSequenceSubStr(slice, 1, 2, 1, Pdonor);

    if (!result)
        return result;

    result = ensSliceFetchSequenceSubStr(slice,
                                         length - 1,
                                         length,
                                         1,
                                         Pacceptor);

    return result;
}




/* @section test **************************************************************
**
** Functions for testing Ensembl Intron objects
**
** @fdata [EnsPIntron]
**
** @nam3rule Is Ensembl Intron has a property
** @nam4rule Canonical
** Test, whether an Ensembl Intron has canonical splice sites
**
** @argrule * intron [const EnsPIntron] Ensembl Intron
** @argrule Canonical Presult [AjBool*] AJAX Boolean address
**
** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
**
** @fcategory use
******************************************************************************/




/* @func ensIntronIsCanonical *************************************************
**
** Test, whether an Ensembl Intron has canonical splice sites.
**
** @cc Bio::EnsEMBL::Intron::is_splice_canonical
** @param [r] intron [const EnsPIntron] Ensembl Intron
** @param [w] Presult [AjBool*] AJAX Boolean address
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.5.0
** @@
******************************************************************************/

AjBool ensIntronIsCanonical(const EnsPIntron intron, AjBool *Presult)
{
    AjPStr both     = NULL;
    AjPStr donor    = NULL;
    AjPStr acceptor = NULL;

    if (!intron)
        return ajFalse;

    if (!Presult)
        return ajFalse;

    *Presult = AJFALSE;

    ensIntronFetchSplicesequences(intron, &donor, &acceptor);

    both = ajStrNew();
    ajStrAppendS(&both, donor);
    ajStrAppendS(&both, acceptor);

    if (ajStrMatchCaseC(both, "GTAG"))
        *Presult = ajTrue;

    if (ajStrMatchCaseC(both, "ATAC"))
        *Presult = ajTrue;

    if (ajStrMatchCaseC(both, "GCAG"))
        *Presult = ajTrue;

    ajStrDel(&both);
    ajStrDel(&donor);
    ajStrDel(&acceptor);

    return ajTrue;
}




/* @section matching **********************************************************
**
** Functions for matching Ensembl Intron objects
**
** @fdata [EnsPIntron]
**
** @nam3rule Match      Test Ensembl Intron objects for identity
** @nam3rule Overlap    Test Ensembl Intron objects for overlap
** @nam3rule Similarity Test Ensembl Intron objects for similarity
**
** @argrule * intron1 [const EnsPIntron] Ensembl Intron
** @argrule * intron2 [const EnsPIntron] Ensembl Intron
**
** @valrule * [AjBool] True on success
**
** @fcategory use
******************************************************************************/




/* @func ensIntronMatch *******************************************************
**
** Test Ensembl Intron objects for identity.
**
** @param [r] intron1 [const EnsPIntron] Ensembl Intron
** @param [r] intron2 [const EnsPIntron] Ensembl Intron
**
** @return [AjBool] ajTrue if the Ensembl Intron objects are equal
**
** @release 6.5.0
** @@
** The comparison is based on an initial pointer equality test and if that
** fails, individual members are compared.
******************************************************************************/

AjBool ensIntronMatch(const EnsPIntron intron1,
                      const EnsPIntron intron2)
{
    if (!intron1)
        return ajFalse;

    if (!intron2)
        return ajFalse;

    if (!ensFeatureMatch(intron1->Feature, intron2->Feature))
        return ajFalse;

    if (!ensExonMatch(intron1->PreviousExon, intron2->PreviousExon))
        return ajFalse;

    if (!ensExonMatch(intron1->NextExon, intron2->NextExon))
        return ajFalse;

    return ajTrue;
}




/* @section map ***************************************************************
**
** Functions for mapping Ensembl Intron objects between
** Ensembl Coordinate System objects.
**
** @fdata [EnsPIntron]
**
** @nam3rule Transfer Transfer an Ensembl Intron
** @nam3rule Transform Transform an Ensembl Intron
**
** @argrule * intron [EnsPIntron] Ensembl Intron
** @argrule Transfer slice [EnsPSlice] Ensembl Slice
** @argrule Transform csname [const AjPStr]
** Ensembl Coordinate System name
** @argrule Transform csversion [const AjPStr]
** Ensembl Coordinate System version
**
** @valrule * [EnsPIntron] Ensembl Intron or NULL
**
** @fcategory misc
******************************************************************************/




/* @func ensIntronTransfer ****************************************************
**
** Transfer an Ensembl Intron onto another Ensembl Slice.
**
** @cc Bio::EnsEMBL::Intron::transfer
** @param [u] intron [EnsPIntron] Ensembl Intron
** @param [u] slice [EnsPSlice] Ensembl Slice
** @see ensFeatureTransfer
**
** @return [EnsPIntron] Ensembl Intron or NULL
**
** @release 6.5.0
** @@
******************************************************************************/

EnsPIntron ensIntronTransfer(EnsPIntron intron,
                             EnsPSlice slice)
{
    EnsPFeature newif = NULL;

    EnsPIntron newintron = NULL;

    if (ajDebugTest("ensIntronTransfer"))
        ajDebug("ensIntronTransfer\n"
                "  intron %p\n"
                "  slice %p\n",
                intron,
                slice);

    if (!intron)
        return NULL;

    if (!slice)
        return NULL;

    if (!intron->Feature)
        ajFatal("ensIntronTransfer cannot transfer an Ensembl Intron "
                "without an Ensembl Feature.\n");

    newif = ensFeatureTransfer(intron->Feature, slice);

    if (!newif)
        return NULL;

    newintron = intronNewCpyFeatures(intron);

    ensIntronSetFeature(newintron, newif);

    ensFeatureDel(&newif);

    return newintron;
}




/* @func ensIntronTransform ***************************************************
**
** Transform an Ensembl Intron into another Ensembl Coordinate System.
**
** @cc Bio::EnsEMBL::Intron::transform
** @param [u] intron [EnsPIntron] Ensembl Intron
** @param [r] csname [const AjPStr] Ensembl Coordinate System name
** @param [r] csversion [const AjPStr] Ensembl Coordinate System version
** @see ensFeatureTransform
**
** @return [EnsPIntron] Ensembl Intron or NULL
**
** @release 6.5.0
** @@
******************************************************************************/

EnsPIntron ensIntronTransform(EnsPIntron intron,
                              const AjPStr csname,
                              const AjPStr csversion)
{
    EnsPFeature newif = NULL;

    EnsPIntron newintron = NULL;

    if (!intron)
        return NULL;

    if (!csname)
        return NULL;

    newif = ensFeatureTransform(intron->Feature,
                                csname,
                                csversion,
                                (EnsPSlice) NULL);

    if (!newif)
        return NULL;

    newintron = intronNewCpyFeatures(intron);

    ensIntronSetFeature(newintron, newif);

    ensFeatureDel(&newif);

    return newintron;
}




/* @datasection [EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
**
** @nam2rule Intronsupportingevidence
** Functions for manipulating Ensembl Intron Supporting Evidence objects
**
** @cc Bio::EnsEMBL::IntronSupportingEvidence
** @cc CVS Revision: 1.4
** @cc CVS Tag: branch-ensembl-68
**
******************************************************************************/




/* @section constructors ******************************************************
**
** All constructors return a new Ensembl Intron Supporting Evidence by pointer.
** It is the responsibility of the user to first destroy any previous
** Intron Supporting Evidence. The target pointer does not need to be
** initialised to NULL, but it is good programming practice to do so anyway.
**
** @fdata [EnsPIntronsupportingevidence]
**
** @nam3rule New Constructor
** @nam4rule Cpy Constructor with existing object
** @nam4rule Ini Constructor with initial values
** @nam4rule Ref Constructor by incrementing the use counter
**
** @argrule Cpy ise [const EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
** @argrule Ini isea [EnsPIntronsupportingevidenceadaptor]
** Ensembl Intron Supporting Evidence Adaptor
** @argrule Ini identifier [ajuint] SQL database internal identifier
** @argrule Ini feature [EnsPFeature] Ensembl Feature
** @argrule Ini intron [EnsPIntron] Ensembl Intron
** @argrule Ini hitname [AjPStr] Hit name
** @argrule Ini canonical [AjBool] Canonical splice sites
** @argrule Ini score [double] Score
** @argrule Ini type [EnsEIntronsupportingevidenceType]
** Ensembl Intron Supporting Evidence Type enumeration
** @argrule Ref ise [EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
**
** @valrule * [EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence or NULL
**
** @fcategory new
******************************************************************************/




/* @func ensIntronsupportingevidenceNewCpy ************************************
**
** Object-based constructor function, which returns an independent object.
**
** @param [r] ise [const EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
**
** @return [EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence or NULL
**
** @release 6.5.0
** @@
******************************************************************************/

EnsPIntronsupportingevidence ensIntronsupportingevidenceNewCpy(
    const EnsPIntronsupportingevidence ise)
{
    EnsPIntronsupportingevidence pthis = NULL;

    if (!ise)
        return NULL;

    AJNEW0(pthis);

    pthis->Use        = 1U;
    pthis->Identifier = ise->Identifier;
    pthis->Adaptor    = ise->Adaptor;
    pthis->Feature    = ensFeatureNewRef(ise->Feature);
    pthis->Intron     = ensIntronNewRef(ise->Intron);

    if (ise->Hitname)
        pthis->Hitname = ajStrNewRef(ise->Hitname);

    pthis->Canonical = ise->Canonical;
    pthis->Score     = ise->Score;
    pthis->Type      = ise->Type;

    return pthis;
}




/* @func ensIntronsupportingevidenceNewIni ************************************
**
** Default constructor for an Ensembl Intron Supporting Evidence
** with initial values.
**
** @cc Bio::EnsEMBL::IntronSupportingtEvidence::new
** @param [u] isea [EnsPIntronsupportingevidenceadaptor]
** Ensembl Intron Supporting Evidence Adaptor
** @param [r] identifier [ajuint] SQL database-internal identifier
** @param [u] feature [EnsPFeature] Ensembl Feature
** @param [u] intron [EnsPIntron] Ensembl Intron
** @param [u] hitname [AjPStr] Hit name
** @param [r] canonical [AjBool] Canonical splice sites
** @param [r] score [double] Score
** @param [u] type [EnsEIntronsupportingevidenceType]
** Ensembl Intron Supporting Evidence Type enumeration
**
** @return [EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence or NULL
**
** @release 6.5.0
** @@
******************************************************************************/

EnsPIntronsupportingevidence ensIntronsupportingevidenceNewIni(
    EnsPIntronsupportingevidenceadaptor isea,
    ajuint identifier,
    EnsPFeature feature,
    EnsPIntron intron,
    AjPStr hitname,
    AjBool canonical,
    double score,
    EnsEIntronsupportingevidenceType type)
{
    EnsPIntronsupportingevidence ise = NULL;

    if (!intron)
        return NULL;

    AJNEW0(ise);

    ise->Use        = 1U;
    ise->Identifier = identifier;
    ise->Adaptor    = isea;

    if (intron)
        ise->Feature = ensFeatureNewCpy(ensIntronGetFeature(intron));
    else
        ise->Feature = ensFeatureNewRef(feature);

    ise->Intron = ensIntronNewRef(intron);

    if (hitname)
        ise->Hitname = ajStrNewRef(hitname);

    if (intron)
        ensIntronIsCanonical(intron, &ise->Canonical);
    else
        ise->Canonical = canonical;

    ise->Score = score;
    ise->Type  = type;

    return ise;
}




/* @func ensIntronsupportingevidenceNewRef ************************************
**
** Ensembl Object referencing function, which returns a pointer to the
** Ensembl Object passed in and increases its reference count.
**
** @param [u] ise [EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
**
** @return [EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence or NULL
**
** @release 6.5.0
** @@
******************************************************************************/

EnsPIntronsupportingevidence ensIntronsupportingevidenceNewRef(
    EnsPIntronsupportingevidence ise)
{
    if (!ise)
        return NULL;

    ise->Use++;

    return ise;
}




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




/* @func ensIntronsupportingevidenceDel ***************************************
**
** Default destructor for an Ensembl Intron Supporting Evidence.
**
** @param [d] Pise [EnsPIntronsupportingevidence*]
** Ensembl Intron Supporting Evidence address
**
** @return [void]
**
** @release 6.5.0
** @@
******************************************************************************/

void ensIntronsupportingevidenceDel(EnsPIntronsupportingevidence *Pise)
{
    EnsPIntronsupportingevidence pthis = NULL;

    if (!Pise)
        return;

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

        ensIntronsupportingevidenceTrace(*Pise, 1);
    }
#endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */

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

        return;
    }

    ensFeatureDel(&pthis->Feature);
    ensIntronDel(&pthis->Intron);

    ajStrDel(&pthis->Hitname);

    ajMemFree((void **) Pise);

    return;
}




/* @section member retrieval **************************************************
**
** Functions for returning members of an
** Ensembl Intron Supporting Evidence object.
**
** @fdata [EnsPIntronsupportingevidence]
**
** @nam3rule Get Return Ensembl Intron Supporting Evidence attribute(s)
** @nam4rule Adaptor Return the Ensembl Intron Supporting Evidence Adaptor
** @nam4rule Canonical Return the canonical splice site member
** @nam4rule Feature Return the Ensembl Feature
** @nam4rule Hitname Return the hit name
** @nam4rule Identifier Return the SQL database-internal identifier
** @nam4rule Intron Return the Ensembl Intron
** @nam4rule Score Return the score
** @nam4rule Type Return the
** Ensembl Intron Supporting Evidence Type enumeration
**
** @argrule * ise [const EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
**
** @valrule Adaptor [EnsPIntronsupportingevidenceadaptor]
** Ensembl Intron Supporting Evidence Adaptor or NULL
** @valrule Canonical [AjBool] Canonical splice sites or AJFALSE
** @valrule Feature [EnsPFeature] Ensembl Feature or NULL
** @valrule Hitname [AjPStr] Hit name
** @valrule Identifier [ajuint] SQL database-internal identifier or 0U
** @valrule Intron [EnsPIntron] Ensembl Intron or NULL
** @valrule Score [double] Score or 0.0
** @valrule Type [EnsEIntronsupportingevidenceType]
** Ensembl Intron Supporting Evidence Type enumeration or
** ensEIntronsupportingevidenceTypeNULL
**
** @fcategory use
******************************************************************************/




/* @func ensIntronsupportingevidenceGetAdaptor ********************************
**
** Get the Ensembl Intron Supporting Evidence Adaptor member of an
** Ensembl Intron Supporting Evidence.
**
** @cc Bio::EnsEMBL::Storable::adaptor
** @param [r] ise [const EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
**
** @return [EnsPIntronsupportingevidenceadaptor]
** Ensembl Intron Supporting Evidence Adaptor or NULL
**
** @release 6.5.0
** @@
******************************************************************************/

EnsPIntronsupportingevidenceadaptor ensIntronsupportingevidenceGetAdaptor(
    const EnsPIntronsupportingevidence ise)
{
    return (ise) ? ise->Adaptor : NULL;
}




/* @func ensIntronsupportingevidenceGetCanonical ******************************
**
** Get the canonical splice sites member of an
** Ensembl Intron Supporting Evidence.
**
** @cc Bio::EnsEMBL::IntronSupportingEvidence::is_splice_canonical
** @param [r] ise [const EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
**
** @return [AjBool] Canonical splice sites or AJFALSE
**
** @release 6.5.0
** @@
******************************************************************************/

AjBool ensIntronsupportingevidenceGetCanonical(
    const EnsPIntronsupportingevidence ise)
{
    return (ise) ? ise->Canonical : AJFALSE;
}




/* @func ensIntronsupportingevidenceGetFeature ********************************
**
** Get the Ensembl Feature member of an
** Ensembl Intron Supporting Evidence.
**
** @cc Bio::EnsEMBL::Feature
** @param [r] ise [const EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
**
** @return [EnsPFeature] Ensembl Feature or NULL
**
** @release 6.5.0
** @@
******************************************************************************/

EnsPFeature ensIntronsupportingevidenceGetFeature(
    const EnsPIntronsupportingevidence ise)
{
    return (ise) ? ise->Feature : NULL;
}




/* @func ensIntronsupportingevidenceGetHitname ********************************
**
** Get the hit name member of an
** Ensembl Intron Supporting Evidence.
**
** @cc Bio::EnsEMBL::IntronSupportingEvidence::hit_name
** @param [r] ise [const EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
**
** @return [AjPStr] Hit name or NULL
**
** @release 6.5.0
** @@
******************************************************************************/

AjPStr ensIntronsupportingevidenceGetHitname(
    const EnsPIntronsupportingevidence ise)
{
    return (ise) ? ise->Hitname : NULL;
}




/* @func ensIntronsupportingevidenceGetIdentifier *****************************
**
** Get the SQL database-internal identifier member of an
** Ensembl Intron Supporting Evidence.
**
** @cc Bio::EnsEMBL::Storable::dbID
** @param [r] ise [const EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
**
** @return [ajuint] SQL database-internal identifier or 0U
**
** @release 6.5.0
** @@
******************************************************************************/

ajuint ensIntronsupportingevidenceGetIdentifier(
    const EnsPIntronsupportingevidence ise)
{
    return (ise) ? ise->Identifier : 0U;
}




/* @func ensIntronsupportingevidenceGetIntron *********************************
**
** Get the Ensembl Intron member of an
** Ensembl Intron Supporting Evidence.
**
** @cc Bio::EnsEMBL::IntronSupportingEvidence::get_Intron
** @param [r] ise [const EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
**
** @return [EnsPIntron] Ensembl Intron or NULL
**
** @release 6.5.0
** @@
******************************************************************************/

EnsPIntron ensIntronsupportingevidenceGetIntron(
    const EnsPIntronsupportingevidence ise)
{
    return (ise) ? ise->Intron : NULL;
}




/* @func ensIntronsupportingevidenceGetScore **********************************
**
** Get the score member of an
** Ensembl Intron Supporting Evidence.
**
** @cc Bio::EnsEMBL::IntronSupportingEvidence::score
** @param [r] ise [const EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
**
** @return [double] Score or 0.0
**
** @release 6.5.0
** @@
******************************************************************************/

double ensIntronsupportingevidenceGetScore(
    const EnsPIntronsupportingevidence ise)
{
    return (ise) ? ise->Score : 0.0;
}




/* @func ensIntronsupportingevidenceGetType ***********************************
**
** Get the Ensembl Intron Supporting Evidence Type enumeration member of an
** Ensembl Intron Supporting Evidence.
**
** @cc Bio::EnsEMBL::IntronSupportingEvidence::score_type
** @param [r] ise [const EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
**
** @return [EnsEIntronsupportingevidenceType]
** Ensembl Intron Supporting Evidence Type enumeration or
** ensEIntronsupportingevidenceTypeNULL
**
** @release 6.5.0
** @@
******************************************************************************/

EnsEIntronsupportingevidenceType ensIntronsupportingevidenceGetType(
    const EnsPIntronsupportingevidence ise)
{
    return (ise) ? ise->Type : ensEIntronsupportingevidenceTypeNULL;
}




/* @section member assignment *************************************************
**
** Functions for assigning members of an
** Ensembl Intron Supporting Evidence object.
**
** @fdata [EnsPIntronsupportingevidence]
**
** @nam3rule Set Set one member of an Ensembl Intron Supporting Evidence
** @nam4rule Feature Set the Ensembl Feature
**
** @argrule * ise [EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
**
** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
** @argrule Feature feature [EnsPFeature] Ensembl Feature
**
** @fcategory modify
******************************************************************************/





/* @func ensIntronsupportingevidenceSetFeature ********************************
**
** Set the Ensembl Feature member of an Ensembl Intron Supporting Evidence.
**
** @cc Bio::EnsEMBL::Feature
** @param [u] ise [EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
** @param [u] feature [EnsPFeature] Ensembl Feature
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.5.0
** @@
******************************************************************************/

AjBool ensIntronsupportingevidenceSetFeature(
    EnsPIntronsupportingevidence ise,
    EnsPFeature feature)
{
    if (!ise)
        return ajFalse;

    ensFeatureDel(&ise->Feature);

    ise->Feature = ensFeatureNewRef(feature);

    return ajTrue;
}




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




/* @func ensIntronsupportingevidenceTrace *************************************
**
** Trace an Ensembl Intron Supporting Evidence.
**
** @param [r] ise [const EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
** @param [r] level [ajuint] Indentation level
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.2.0
** @@
******************************************************************************/

AjBool ensIntronsupportingevidenceTrace(
    const EnsPIntronsupportingevidence ise,
    ajuint level)
{
    AjPStr indent = NULL;

    if (!ise)
        return ajFalse;

    indent = ajStrNew();

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

    ajDebug("%ensIntronsupportingevidenceTrace %p\n"
            "%S  Use %u\n"
            "%S  Identifier %u\n"
            "%S  Adaptor %p\n"
            "%S  Feature %p\n"
            "%S  Intron %p\n"
            "%S  Hitname '%S'\n"
            "%S  Canonical '%B'\n"
            "%S  Score %f.3\n"
            "%S  Type '%s'\n",
            indent, ise,
            indent, ise->Use,
            indent, ise->Identifier,
            indent, ise->Adaptor,
            indent, ise->Feature,
            indent, ise->Intron,
            indent, ise->Hitname,
            indent, ise->Canonical,
            indent, ise->Score,
            indent, ensIntronsupportingevidenceTypeToChar(ise->Type));

    ensFeatureTrace(ise->Feature, level + 1);
    ensIntronTrace(ise->Intron, level + 1);

    ajStrDel(&indent);

    return ajTrue;
}




/* @section calculate *********************************************************
**
** Functions for calculating information from an
** Ensembl Intron Supporting Evidence object.
**
** @fdata [EnsPIntronsupportingevidence]
**
** @nam3rule Calculate Calculate Ensembl Intron Supporting Evidence information
** @nam4rule Memsize Calculate the memory size in bytes
**
** @argrule * ise [const EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
**
** @valrule Memsize [size_t] Memory size in bytes or 0
**
** @fcategory misc
******************************************************************************/




/* @func ensIntronsupportingevidenceCalculateMemsize **************************
**
** Calculate the memory size in bytes of an
** Ensembl Intron Supporting Evidence.
**
** @param [r] ise [const EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
**
** @return [size_t] Memory size in bytes or 0
**
** @release 6.5.0
** @@
******************************************************************************/

size_t ensIntronsupportingevidenceCalculateMemsize(
    const EnsPIntronsupportingevidence ise)
{
    size_t size = 0;

    if (!ise)
        return 0;

    size += sizeof (EnsOIntronsupportingevidence);

    size += ensFeatureCalculateMemsize(ise->Feature);
    size += ensIntronCalculateMemsize(ise->Intron);

    if (ise->Hitname)
    {
        size += sizeof (AjOStr);

        size += ajStrGetRes(ise->Hitname);
    }

    return size;
}




/* @section fetch *************************************************************
**
** Functions for fetching information from an
** Ensembl Intron Supporting Evidence object.
**
** @fdata [EnsPIntronsupportingevidence]
**
** @nam3rule Fetch Fetch Ensembl Intron Supporting Evidence information
** @nam4rule All   Fetch all Ensembl Intron Supporting Evidence information
** @nam4rule Exons Fetch Ensembl Exon objects
**
** @argrule * ise [const EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
** @argrule Exons transcript [EnsPTranscript] Ensembl Transcript
** @argrule Exons Pprevious [EnsPExon*] Previous Ensembl Exon
** @argrule Exons Pnext [EnsPExon*] Next Ensembl Exon
**
** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
**
** @fcategory misc
******************************************************************************/




/* @func ensIntronsupportingevidenceFetchExons ********************************
**
** Fetch Ensembl Exon objects for an Ensembl Intron Supporting Evidence.
**
** @cc Bio::EnsEMBL::Intron::find_previous_Exon
** @cc Bio::EnsEMBL::Intron::find_next_Exon
** @param [r] ise [const EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
** @param [u] transcript [EnsPTranscript] Ensembl Transcript
** @param [wP] Pprevious [EnsPExon*] Previous Ensembl Exon address
** @param [wP] Pnext [EnsPExon*] Next Ensembl Exon address
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.5.0
** @@
******************************************************************************/

AjBool ensIntronsupportingevidenceFetchExons(
    const EnsPIntronsupportingevidence ise,
    EnsPTranscript transcript,
    EnsPExon *Pprevious,
    EnsPExon *Pnext)
{
    ajuint previous = 0U;
    ajuint next     = 0U;

    const AjPList exons = NULL;
    AjIList iter = NULL;

    EnsPExon exon = NULL;

    EnsPFeature efeature = NULL;
    EnsPFeature ifeature = NULL;

    if (!ise)
        return ajFalse;

    if (!transcript)
        return ajFalse;

    if (!Pprevious)
        return ajFalse;

    if (!Pnext)
        return ajFalse;

    *Pprevious = NULL;
    *Pnext    = NULL;

    ifeature = ensIntronsupportingevidenceGetFeature(ise);

    if (ise->Adaptor)
        ensIntronsupportingevidenceadaptorRetrieveExonidentifiers(
            ise->Adaptor,
            ise,
            transcript,
            &previous,
            &next);

    exons = ensTranscriptLoadExons(transcript);

    iter = ajListIterNewread(exons);

    while (!ajListIterDone(iter))
    {
        exon = (EnsPExon) ajListIterGet(iter);

        if (previous && next)
        {
            /* For perstent objects stored in a database. */

            if (ensExonGetIdentifier(exon) == previous)
                *Pprevious = ensExonNewRef(exon);

            if (ensExonGetIdentifier(exon) == next)
                *Pnext = ensExonNewRef(exon);
        }
        else
        {
            efeature = ensExonGetFeature(exon);

            if (ensFeatureGetStrand(ifeature) >= 0)
            {
                if (ensFeatureGetEnd(efeature) ==
                    (ensFeatureGetStart(ifeature) - 1))
                    *Pprevious = ensExonNewRef(exon);

                if (ensFeatureGetStart(efeature) ==
                    (ensFeatureGetEnd(ifeature) + 1))
                    *Pnext = ensExonNewRef(exon);
            }
            else
            {
                if (ensFeatureGetStart(efeature) ==
                    (ensFeatureGetEnd(ifeature) + 1))
                    *Pprevious = ensExonNewRef(exon);

                if (ensFeatureGetEnd(efeature) ==
                    (ensFeatureGetStart(ifeature) - 1))
                    *Pnext = ensExonNewRef(exon);

            }
        }
    }

    ajListIterDel(&iter);

    return ajTrue;
}




/* @section matching **********************************************************
**
** Functions for matching Ensembl Intron Supporting Evidence objects
**
** @fdata [EnsPIntronsupportingevidence]
**
** @nam3rule Match      Test for identity
** @nam3rule Overlap    Test for overlap
** @nam3rule Similarity Test for similarity
**
** @argrule * ise1 [const EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
** @argrule * ise2 [const EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
**
** @valrule * [AjBool] True on success
**
** @fcategory use
******************************************************************************/




/* @func ensIntronsupportingevidenceMatch *************************************
**
** Test Ensembl Intron Supporting Evidence objects for identity.
**
** @cc Bio::EnsEMBL::IntronSupportingEvidence::equals
** @param [r] ise1 [const EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
** @param [r] ise2 [const EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
**
** @return [AjBool] ajTrue if the Ensembl Intron Supporting Evidence objects
** are equal
**
** @release 6.5.0
** @@
** The comparison is based on an initial pointer equality test and if that
** fails, individual members are compared.
******************************************************************************/

AjBool ensIntronsupportingevidenceMatch(
    const EnsPIntronsupportingevidence ise1,
    const EnsPIntronsupportingevidence ise2)
{
    if (!ise1)
        return ajFalse;

    if (!ise2)
        return ajFalse;

    if (ise1 == ise2)
        return ajTrue;

    if (ise1->Identifier != ise2->Identifier)
        return ajFalse;

    if ((ise1->Adaptor && ise2->Adaptor) && (ise1->Adaptor != ise2->Adaptor))
        return ajFalse;

    if (!ensFeatureMatch(ise1->Feature, ise2->Feature))
        return ajFalse;

    if ((ise1->Intron && ise2->Intron) &&
        !ensIntronMatch(ise1->Intron, ise2->Intron))
        return ajFalse;

    if (!ajStrMatchCaseS(ise1->Hitname, ise2->Hitname))
        return ajFalse;

    if (ise1->Canonical != ise2->Canonical)
        return ajFalse;

    if (ise1->Score != ise2->Score)
        return ajFalse;

    return ajTrue;
}




/* @section map ***************************************************************
**
** Functions for mapping Ensembl Intron Supporting Evidence objects between
** Ensembl Coordinate System objects.
**
** @fdata [EnsPIntronsupportingevidence]
**
** @nam3rule Transfer Transfer an Ensembl Intron Supporting Evidence
** @nam3rule Transform Transform an Ensembl Intron Supporting Evidence
**
** @argrule * ise [EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
** @argrule Transfer slice [EnsPSlice] Ensembl Slice
** @argrule Transform csname [const AjPStr]
** Ensembl Coordinate System name
** @argrule Transform csversion [const AjPStr]
** Ensembl Coordinate System version
**
** @valrule * [EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence or NULL
**
** @fcategory misc
******************************************************************************/




/* @func ensIntronsupportingevidenceTransfer **********************************
**
** Transfer an Ensembl Intron Supporting Evidence onto another Ensembl Slice.
**
** @cc Bio::EnsEMBL::IntronSupportingEvidence::transfer
** @param [u] ise [EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
** @param [u] slice [EnsPSlice] Ensembl Slice
** @see ensFeatureTransfer
**
** @return [EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence or NULL
**
** @release 6.5.0
** @@
******************************************************************************/

EnsPIntronsupportingevidence ensIntronsupportingevidenceTransfer(
    EnsPIntronsupportingevidence ise,
    EnsPSlice slice)
{
    EnsPFeature newfeature = NULL;

    EnsPIntronsupportingevidence newise = NULL;

    if (!ise)
        return NULL;

    if (!slice)
        return NULL;

    newfeature = ensFeatureTransfer(ise->Feature, slice);

    if (!newfeature)
        return NULL;

    newise = ensIntronsupportingevidenceNewCpy(ise);

    ensIntronsupportingevidenceSetFeature(newise, newfeature);

    return newise;
}




/* @func ensIntronsupportingevidenceTransform *********************************
**
** Transform an Ensembl Intron Supporting Feature into another
** Ensembl Coordinate System.
**
** @cc Bio::EnsEMBL::IntronSupportingFeature::transform
** @param [u] ise [EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
** @param [r] csname [const AjPStr] Ensembl Coordinate System name
** @param [r] csversion [const AjPStr] Ensembl Coordinate System version
** @see ensFeatureTransform
**
** @return [EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence or NULL
**
** @release 6.5.0
** @@
******************************************************************************/

EnsPIntronsupportingevidence ensIntronsupportingevidenceTransform(
    EnsPIntronsupportingevidence ise,
    const AjPStr csname,
    const AjPStr csversion)
{
    EnsPFeature newfeature = NULL;

    EnsPIntronsupportingevidence newise = NULL;

    if (!ise)
        return NULL;

    if (!csname)
        return NULL;

    newfeature = ensFeatureTransform(ise->Feature,
                                     csname,
                                     csversion,
                                     (EnsPSlice) NULL);

    if (!newfeature)
        return NULL;

    newise = ensIntronsupportingevidenceNewCpy(ise);

    ensIntronsupportingevidenceSetFeature(newise, newfeature);

    return newise;
}




/* @section test **************************************************************
**
** Functions for testing Ensembl Intron Supporting Evidence objects
**
** @fdata [EnsPIntronsupportingevidence]
**
** @nam3rule Has Ensembl Intron Supporting Evidence has a property
** @nam4rule Transcripts
** Test, whether an Ensembl Intron Supporting Evidnce has
** Ensembl Transcript objects linked
**
** @argrule * ise [const EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
** @argrule Transcripts Presult [AjBool*] AJAX Boolean address
**
** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
**
** @fcategory use
******************************************************************************/




/* @func ensIntronsupportingevidenceHasTranscripts ****************************
**
** Test, whether an Ensembl Intron has Ensembl Transcript objects linked.
**
** @cc Bio::EnsEMBL::Intron::is_splice_canonical
** @param [r] ise [const EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
** @param [w] Presult [AjBool*] AJAX Boolean address
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.5.0
** @@
******************************************************************************/

AjBool ensIntronsupportingevidenceHasTranscripts(
    const EnsPIntronsupportingevidence ise,
    AjBool *Presult)
{
    AjBool result = AJFALSE;

    AjPList identifiers = NULL;

    if (!ise)
        return ajFalse;

    if (!Presult)
        return ajFalse;

    *Presult = ajFalse;

    result = ensIntronsupportingevidenceadaptorRetrieveAllTranscriptidentifiers(
        ise->Adaptor,
        ise,
        identifiers);

    if (ajListGetLength(identifiers))
        *Presult = ajTrue;
    else
        *Presult = ajFalse;

    ajListFreeData(&identifiers);

    return result;
}




/* @datasection [EnsEIntronsupportingevidenceType]
** Ensembl Intron Supporting Evidence Type
**
** @nam2rule Intronsupportingevidence Functions for manipulating
** Ensembl Intron Supporting Evidence objects
** @nam3rule IntronsupportingevidenceType Functions for manipulating
** Ensembl Intron Supporting Evidence Type enumerations
**
******************************************************************************/




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




/* @func ensIntronsupportingevidenceTypeFromStr *******************************
**
** Return an Ensembl Intron Supporting Evidence Type enumeration
** from an AJAX String.
**
** @param [r] type [const AjPStr] Type string
**
** @return [EnsEIntronsupportingevidenceType]
** Ensembl Intron Supporting Evidence Type enumeration or
** ensEIntronsupportingevidenceTypeNULL
**
** @release 6.5.0
** @@
******************************************************************************/

EnsEIntronsupportingevidenceType ensIntronsupportingevidenceTypeFromStr(
    const AjPStr type)
{
    register EnsEIntronsupportingevidenceType i =
        ensEIntronsupportingevidenceTypeNULL;

    EnsEIntronsupportingevidenceType iset =
        ensEIntronsupportingevidenceTypeNULL;

    for (i = ensEIntronsupportingevidenceTypeNULL;
         intronsupportingevidenceKType[i];
         i++)
        if (ajStrMatchC(type, intronsupportingevidenceKType[i]))
            iset = i;

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

    return iset;
}




/* @section Cast **************************************************************
**
** Functions for returning attributes of an
** Ensembl Intron Supporting Evidence Type enumeration.
**
** @fdata [EnsEIntronsupportingevidenceType]
**
** @nam4rule To   Return Ensembl Intron Supporting Evidence Type enumeration
** @nam5rule Char Return C character string value
**
** @argrule To iset [EnsEIntronsupportingevidenceType]
** Ensembl Intron Supporting Evidence Type enumeration
**
** @valrule Char [const char*] Status
**
** @fcategory cast
******************************************************************************/




/* @func ensIntronsupportingevidenceTypeToChar ********************************
**
** Cast an Ensembl Intron Supporting Evidence Type enumeration
** into a C-type (char *) string.
**
** @param [u] iset [EnsEIntronsupportingevidenceType]
** Ensembl Intron Supporting Evidence Type enumeration
**
** @return [const char*]
** Ensembl Intron Supporting Evidence Type C-type (char *) string
**
** @release 6.5.0
** @@
******************************************************************************/

const char* ensIntronsupportingevidenceTypeToChar(
    EnsEIntronsupportingevidenceType iset)
{
    register EnsEIntronsupportingevidenceType i =
        ensEIntronsupportingevidenceTypeNULL;

    for (i = ensEIntronsupportingevidenceTypeNULL;
         intronsupportingevidenceKType[i] && (i < iset);
         i++);

    if (!intronsupportingevidenceKType[i])
        ajDebug("ensIntronsupportingevidenceTypeToChar "
                "encountered an out of boundary error on "
                "Ensembl Intron Supporting Evidence Type "
                "enumeration %d.\n",
                iset);

    return intronsupportingevidenceKType[i];
}




/* @datasection [EnsPIntronsupportingevidenceadaptor]
** Ensembl Intron Supporting Evidence Adaptor
**
** @nam2rule Intronsupportingevidenceadaptor Functions for manipulating
** Ensembl Intron Supporting Evidence Adaptor objects
**
** @cc Bio::EnsEMBL::DBSQL::IntronSupportingEvidenceAdaptor
** @cc CVS Revision: 1.2
** @cc CVS Tag: branch-ensembl-68
**
******************************************************************************/




/* @funcstatic intronsupportingevidenceadaptorFetchAllbyStatement *************
**
** Run a SQL statement against an Ensembl Database Adaptor and consolidate the
** results into an AJAX List of Ensembl Intron Supporting Evidence objects.
**
** @cc Bio::EnsEMBL::DBSQL::IntronSupportingEvidenceAdaptor::_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] ises [AjPList] AJAX List of
** Ensembl Intron Supporting Evidence objects
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.4.0
** @@
******************************************************************************/

static AjBool intronsupportingevidenceadaptorFetchAllbyStatement(
    EnsPBaseadaptor ba,
    const AjPStr statement,
    EnsPAssemblymapper am,
    EnsPSlice slice,
    AjPList ises)
{
    double score = 0.0;

    ajuint identifier = 0U;

    ajuint srid       = 0U;
    ajuint srstart    = 0U;
    ajuint srend      = 0U;
    ajint  srstrand   = 0;
    ajuint analysisid = 0U;

    AjBool canonical = AJFALSE;

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

    AjPStr hitname = NULL;
    AjPStr type    = NULL;

    EnsPFeature feature = NULL;

    EnsPIntron intron = NULL;

    EnsPIntronsupportingevidence        ise  = NULL;
    EnsPIntronsupportingevidenceadaptor isea = NULL;

    EnsEIntronsupportingevidenceType iset =
        ensEIntronsupportingevidenceTypeNULL;

    EnsPDatabaseadaptor dba = NULL;

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

    if (!ba)
        return ajFalse;

    if (!statement)
        return ajFalse;

    if (!ises)
        return ajFalse;

    dba = ensBaseadaptorGetDatabaseadaptor(ba);

    isea = ensRegistryGetIntronsupportingevidenceadaptor(dba);

    sqls = ensDatabaseadaptorSqlstatementNew(dba, statement);

    sqli = ajSqlrowiterNew(sqls);

    while (!ajSqlrowiterDone(sqli))
    {
        identifier = 0U;
        srid       = 0U;
        srstart    = 0U;
        srend      = 0U;
        srstrand   = 0;
        analysisid = 0U;
        hitname    = ajStrNew();
        score      = 0.0;
        type       = ajStrNew();
        canonical  = AJFALSE;

        sqlr = ajSqlrowiterGet(sqli);

        ajSqlcolumnToUint(sqlr, &identifier);
        ajSqlcolumnToUint(sqlr, &srid);
        ajSqlcolumnToUint(sqlr, &srstart);
        ajSqlcolumnToUint(sqlr, &srend);
        ajSqlcolumnToInt(sqlr, &srstrand);
        ajSqlcolumnToUint(sqlr, &analysisid);
        ajSqlcolumnToStr(sqlr, &hitname);
        ajSqlcolumnToDouble(sqlr, &score);
        ajSqlcolumnToStr(sqlr, &type);
        ajSqlcolumnToBool(sqlr, &canonical);

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

        if (!feature)
        {
            ajStrDel(&hitname);
            ajStrDel(&type);

            continue;
        }

        iset = ensIntronsupportingevidenceTypeFromStr(type);

        if (!iset)
            ajDebug("intronsupportingevidenceadaptorFetchAllbyStatement "
                    "encountered unexpected string '%S' in the "
                    "'intron_supporting_evidence.score_type' field.\n",
                    type);

        ise = ensIntronsupportingevidenceNewIni(
            isea,
            identifier,
            feature,
            (EnsPIntron) NULL,
            hitname,
            canonical,
            score,
            iset);

        ajListPushAppend(ises, (void *) ise);

        ensFeatureDel(&feature);
        ensIntronDel(&intron);

        ajStrDel(&hitname);
        ajStrDel(&type);
    }

    ajSqlrowiterDel(&sqli);

    ensDatabaseadaptorSqlstatementDel(dba, &sqls);

    return ajTrue;
}




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




/* @func ensIntronsupportingevidenceadaptorNew ********************************
**
** Default constructor for an Ensembl Intron Supporting Evidence 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 ensRegistryGetIntronsupportingevidenceadaptor
**
** @cc Bio::EnsEMBL::DBSQL::IntronSupportingEvidenceAdaptor::new
** @param [u] dba [EnsPDatabaseadaptor] Ensembl Database Adaptor
**
** @return [EnsPIntronsupportingevidenceadaptor]
** Ensembl Intron Supporting Evidence Adaptor or NULL
**
** @release 6.5.0
** @@
******************************************************************************/

EnsPIntronsupportingevidenceadaptor ensIntronsupportingevidenceadaptorNew(
    EnsPDatabaseadaptor dba)
{
    return ensFeatureadaptorNew(
        dba,
        intronsupportingevidenceadaptorKTablenames,
        intronsupportingevidenceadaptorKColumnnames,
        (const EnsPBaseadaptorLeftjoin) NULL,
        (const char *) NULL,
        (const char *) NULL,
        &intronsupportingevidenceadaptorFetchAllbyStatement,
        (void *(*)(const void *)) NULL,
        (void *(*)(void *)) &ensIntronsupportingevidenceNewRef,
        (AjBool (*)(const void *)) NULL,
        (void (*)(void **)) NULL,
        (size_t (*)(const void *)) &ensIntronsupportingevidenceCalculateMemsize,
        (EnsPFeature (*)(const void *)) &ensIntronsupportingevidenceGetFeature,
        "Intronsupportingevidence");
}




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




/* @func ensIntronsupportingevidenceadaptorDel ********************************
**
** Default destructor for an Ensembl Intron Supporting Evidence 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] Pisea [EnsPIntronsupportingevidenceadaptor*]
** Ensembl Intron Supporting Evidence Adaptor address
**
** @return [void]
**
** @release 6.5.0
** @@
******************************************************************************/

void ensIntronsupportingevidenceadaptorDel(
    EnsPIntronsupportingevidenceadaptor *Pisea)
{
    ensFeatureadaptorDel(Pisea);

    return;
}




/* @section member retrieval **************************************************
**
** Functions for returning members of an
** Ensembl Intron Supporting Evidence Adaptor object.
**
** @fdata [EnsPIntronsupportingevidenceadaptor]
**
** @nam3rule Get Return Ensembl Intron Supporting Evidence Adaptor attribute(s)
** @nam4rule Baseadaptor Return the Ensembl Base Adaptor
** @nam4rule Databaseadaptor Return the Ensembl Database Adaptor
** @nam4rule Featureadaptor Return the Ensembl Feature Adaptor
**
** @argrule * isea [EnsPIntronsupportingevidenceadaptor]
** Ensembl Intron Supporting Evidence 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 ensIntronsupportingevidenceadaptorGetBaseadaptor *********************
**
** Get the Ensembl Base Adaptor member of an
** Ensembl Intron Supporting Evidence Adaptor.
**
** @param [u] isea [EnsPIntronsupportingevidenceadaptor]
** Ensembl Intron Supporting Evidence Adaptor
**
** @return [EnsPBaseadaptor] Ensembl Base Adaptor or NULL
**
** @release 6.5.0
** @@
******************************************************************************/

EnsPBaseadaptor ensIntronsupportingevidenceadaptorGetBaseadaptor(
    EnsPIntronsupportingevidenceadaptor isea)
{
    return ensFeatureadaptorGetBaseadaptor(
        ensIntronsupportingevidenceadaptorGetFeatureadaptor(isea));
}




/* @func ensIntronsupportingevidenceadaptorGetDatabaseadaptor *****************
**
** Get the Ensembl Database Adaptor member of an
** Ensembl Intron Supporting Evidence Adaptor.
**
** @param [u] isea [EnsPIntronsupportingevidenceadaptor]
** Ensembl Intron Supporting Evidence Adaptor
**
** @return [EnsPDatabaseadaptor] Ensembl Database Adaptor or NULL
**
** @release 6.5.0
** @@
******************************************************************************/

EnsPDatabaseadaptor ensIntronsupportingevidenceadaptorGetDatabaseadaptor(
    EnsPIntronsupportingevidenceadaptor isea)
{
    return ensFeatureadaptorGetDatabaseadaptor(
        ensIntronsupportingevidenceadaptorGetFeatureadaptor(isea));
}




/* @func ensIntronsupportingevidenceadaptorGetFeatureadaptor ******************
**
** Get the Ensembl Feature Adaptor member of an
** Ensembl Intron Supporting Evidence Adaptor.
**
** @param [u] isea [EnsPIntronsupportingevidenceadaptor]
** Ensembl Intron Supporting Evidence Adaptor
**
** @return [EnsPFeatureadaptor] Ensembl Feature Adaptor or NULL
**
** @release 6.5.0
** @@
******************************************************************************/

EnsPFeatureadaptor ensIntronsupportingevidenceadaptorGetFeatureadaptor(
    EnsPIntronsupportingevidenceadaptor isea)
{
    return isea;
}




/* @section canonical object retrieval ****************************************
**
** Functions for fetching Ensembl Intron Supporting Evidence objects from an
** Ensembl SQL database.
**
** @fdata [EnsPIntronsupportingevidenceadaptor]
**
** @nam3rule Fetch  Fetch Ensembl Intron Supporting Evidence object(s)
** @nam4rule All    Fetch all Ensembl Intron Supporting Evidence objects
** @nam4rule Allby  Fetch all Ensembl Intron Supporting Evidence objects
** matching a criterion
** @nam5rule Transcript Fetch all by an Ensembl Transcript
** @nam4rule By     Fetch one Ensembl Intron Supporting Evidence object
** matching a criterion
** @nam5rule Identifier Fetch by an SQL database-internal identifier
**
** @argrule * isea [EnsPIntronsupportingevidenceadaptor]
** Ensembl Intron Supporting Evidence Adaptor
** @argrule All ises [AjPList]
** AJAX List of Ensembl Intron Supporting Evidence objects
** @argrule AllbyTranscript transcript [const EnsPTranscript]
** Ensembl Transcript
** @argrule Allby ises [AjPList]
** AJAX List of Ensembl Intron Supporting Evidence objects
** @argrule ByIdentifier identifier [ajuint] SQL database-internal identifier
** @argrule By Pise [EnsPIntronsupportingevidence*]
** Ensembl Intron Supporting Evidence address
**
** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
**
** @fcategory use
******************************************************************************/




/* @func ensIntronsupportingevidenceadaptorFetchAllbyTranscript ***************
**
** Fetch all Ensembl Intron Supporting Evidence objects via an
** Ensembl Transcript object.
**
** The caller is responsible for deleting the
** Ensembl Intron Supporting Evidence objects before deleting the AJAX List.
**
** @cc Bio::EnsEMBL::Map::DBSQL::IntronSupportingEvidenceAdaptor::
** fetch_all_by_Transcript
** @param [u] isea [EnsPIntronsupportingevidenceadaptor]
** Ensembl Intron Supporting Evidence Adaptor
** @param [r] transcript [const EnsPTranscript] Ensembl Transcript
** @param [u] ises [AjPList]
** AJAX List of Ensembl Intron Supporting Evidence objects
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.2.0
** @@
******************************************************************************/

AjBool ensIntronsupportingevidenceadaptorFetchAllbyTranscript(
    EnsPIntronsupportingevidenceadaptor isea,
    const EnsPTranscript transcript,
    AjPList ises)
{
    void **valarray = NULL;

    register ajuint i = 0U;

    ajuint *Pidentifier = NULL;

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

    AjPStr statement = NULL;

    AjPTable table = NULL;

    EnsPDatabaseadaptor dba = NULL;

    if (!isea)
        return ajFalse;

    if (!transcript)
        return ajFalse;

    if (!ises)
        return ajFalse;

    dba = ensIntronsupportingevidenceadaptorGetDatabaseadaptor(isea);

    statement = ajFmtStr(
        "SELECT "
        "intron_supporting_evidence_id "
        "FROM "
        "transcript_intron_supporting_evidence "
        "WHERE "
        "intron_supporting_evidence_id.transcript_id = %u",
        ensTranscriptGetIdentifier(transcript));

    sqls = ensDatabaseadaptorSqlstatementNew(dba, statement);

    ajStrDel(&statement);

    table = ajTableuintNew(ajSqlstatementGetSelectedrows(sqls));

    ajTableSetDestroyvalue(
        table,
        (void (*)(void **)) &ensIntronsupportingevidenceDel);

    sqli = ajSqlrowiterNew(sqls);

    while (!ajSqlrowiterDone(sqli))
    {
        AJNEW0(Pidentifier);

        sqlr = ajSqlrowiterGet(sqli);

        ajSqlcolumnToUint(sqlr, Pidentifier);

        ajTablePut(table, (void *) Pidentifier, NULL);
    }

    ajSqlrowiterDel(&sqli);

    ensDatabaseadaptorSqlstatementDel(dba, &sqls);

    ensBaseadaptorFetchAllbyIdentifiers(
        ensIntronsupportingevidenceadaptorGetBaseadaptor(isea),
        (EnsPSlice) NULL,
        (ajuint (*)(const void *)) &ensIntronsupportingevidenceGetIdentifier,
        table);

    ajTableToarrayValues(table, &valarray);

    for (i = 0U; valarray[i]; i++)
        ajListPushAppend(ises,
                         (void *) ensIntronsupportingevidenceNewRef(
                             (EnsPIntronsupportingevidence) valarray[i]));

    AJFREE(valarray);

    ajTableDel(&table);

    return ajTrue;
}




/* @func ensIntronsupportingevidenceadaptorFetchByIdentifier ******************
**
** Fetch an Ensembl Intron Supporting Evidence via its
** SQL database-internal identifier.
**
** The caller is responsible for deleting the
** Ensembl Intron Supporting Evidence.
**
** @cc Bio::EnsEMBL::Map::DBSQL::IntronSupportingEvidenceAdaptor::fetch_by_dbID
** @param [u] isea [EnsPIntronsupportingevidenceadaptor]
** Ensembl Intron Supporting Evidence Adaptor
** @param [r] identifier [ajuint] SQL database-internal identifier
** @param [wP] Pise [EnsPIntronsupportingevidence*]
** Ensembl Intron Supporting Evidence address
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.2.0
** @@
******************************************************************************/

AjBool ensIntronsupportingevidenceadaptorFetchByIdentifier(
    EnsPIntronsupportingevidenceadaptor isea,
    ajuint identifier,
    EnsPIntronsupportingevidence *Pise)
{
    return ensBaseadaptorFetchByIdentifier(
        ensIntronsupportingevidenceadaptorGetBaseadaptor(isea),
        identifier,
        (void **) Pise);
}




/* @section accessory object retrieval ****************************************
**
** Functions for retrieving objects releated to
** Ensembl Intron Supporting Evidence objects
** from an Ensembl SQL database.
**
** @fdata [EnsPIntronsupportingevidenceadaptor]
**
** @nam3rule Retrieve
** Retrieve Ensembl Intron Supporting Evidence-releated object(s)
** @nam4rule All
** Retrieve all Ensembl Intron Supporting Evidence-releated objects
** @nam5rule Identifiers Retrieve all SQL database-internal identifier objects
** @nam5rule Transcriptidentifiers
** Retrieve all AJAX unsigned integer (Ensembl Transcript identifier) objects
** @nam4rule Exonidentifiers
** Retrive AJAX unsigned integer (Ensembl Exon identifier) objects
**
** @argrule * isea [EnsPIntronsupportingevidenceadaptor]
** Ensembl Intron Supporting Evidence Adaptor
** @argrule AllIdentifiers identifiers [AjPList]
** AJAX List of AJAX unsigned integer
** (Ensembl Intron Supporting Evidence identifier) objects
** @argrule AllTranscriptidentifiers ise [const EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
** @argrule AllTranscriptidentifiers transcriptids [AjPList]
** AJAX List of AJAX unsigned integer (Ensembl Transcript identifier) objects
** @argrule Exonidentifiers ise [const EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
** @argrule Exonidentifiers transcript [const EnsPTranscript]
** Ensembl Transcript
** @argrule Exonidentifiers Previous [ajuint*]
** Previous Ensembl Exon identifier
** @argrule Exonidentifiers Pnext [ajuint*]
** Next Ensembl Exon identifier
**
** @valrule * [AjBool] ajTrue upon success, ajFalse otherwise
**
** @fcategory use
******************************************************************************/




/* @func ensIntronsupportingevidenceadaptorRetrieveAllTranscriptidentifiers ***
**
** Retrieve all Ensembl Transcript identifier objects of an
** Ensembl Intron Supporting Evidence.
**
** @cc Bio::EnsEMBL::Map::DBSQL::IntronSupportingEvidenceAdaptor::
** list_linked_transcript_ids
** @param [u] isea [EnsPIntronsupportingevidenceadaptor]
** Ensembl Intron Supporting Evidence Adaptor
** @param [r] ise [const EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
** @param [u] transcriptids [AjPList]
** AJAX List of AJAX unsigned integer (Ensembl Transcript identifier) objects
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.5.0
** @@
******************************************************************************/

AjBool ensIntronsupportingevidenceadaptorRetrieveAllTranscriptidentifiers(
    EnsPIntronsupportingevidenceadaptor isea,
    const EnsPIntronsupportingevidence ise,
    AjPList transcriptids)
{
    ajuint *Pidentifier = NULL;

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

    AjPStr statement = NULL;

    EnsPDatabaseadaptor dba = NULL;

    if (!isea)
        return ajFalse;

    if (!ise)
        return ajFalse;

    if (!transcriptids)
        return ajFalse;

    dba = ensIntronsupportingevidenceadaptorGetDatabaseadaptor(isea);

    statement = ajFmtStr(
        "SELECT "
        "transcript_intron_supporting_evidence.transcript_id "
        "FROM "
        "transcript_intron_supporting_evidence "
        "WHERE "
        "transcript_intron_supporting_evidence."
        "intron_supporting_evidence_id = %u",
        ensIntronsupportingevidenceGetIdentifier(ise));

    sqls = ensDatabaseadaptorSqlstatementNew(dba, statement);

    sqli = ajSqlrowiterNew(sqls);

    while (!ajSqlrowiterDone(sqli))
    {
        AJNEW0(Pidentifier);

        sqlr = ajSqlrowiterGet(sqli);

        ajSqlcolumnToUint(sqlr, Pidentifier);

        ajListPushAppend(transcriptids, (void *) Pidentifier);
    }

    ajSqlrowiterDel(&sqli);

    ensDatabaseadaptorSqlstatementDel(dba, &sqls);

    ajStrDel(&statement);

    return ajTrue;
}




/* @func ensIntronsupportingevidenceadaptorRetrieveExonidentifiers ************
**
** Retrieve Ensembl Exon identifiers of an
** Ensembl Intron Supporting Evidence.
**
** @cc Bio::EnsEMBL::Map::DBSQL::IntronSupportingEvidenceAdaptor::
** fetch_flanking_exon_ids
** @param [u] isea [EnsPIntronsupportingevidenceadaptor]
** Ensembl Intron Supporting Evidence Adaptor
** @param [r] ise [const EnsPIntronsupportingevidence]
** Ensembl Intron Supporting Evidence
** @param [r] transcript [const EnsPTranscript] Ensembl Transcript
** @param [wP] Previous [ajuint*] Previous Ensembl Exon identifier
** @param [wP] Pnext [ajuint*] Next Ensembl Exon identifier
**
** @return [AjBool] ajTrue upon success, ajFalse otherwise
**
** @release 6.5.0
** @@
******************************************************************************/

AjBool ensIntronsupportingevidenceadaptorRetrieveExonidentifiers(
    EnsPIntronsupportingevidenceadaptor isea,
    const EnsPIntronsupportingevidence ise,
    const EnsPTranscript transcript,
    ajuint *Previous,
    ajuint *Pnext)
{
    ajuint previousid = 0U;
    ajuint nextid     = 0U;

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

    AjPStr statement = NULL;

    EnsPDatabaseadaptor dba = NULL;

    if (!isea)
        return ajFalse;

    if (!ise)
        return ajFalse;

    if (!transcript)
        return ajFalse;

    if (!Previous)
        return ajFalse;

    if (!Pnext)
        return ajFalse;

    *Previous = 0U;
    *Pnext    = 0U;

    dba = ensIntronsupportingevidenceadaptorGetDatabaseadaptor(isea);

    statement = ajFmtStr(
        "SELECT "
        "transcript_intron_supporting_evidence.previous_exon_id, "
        "transcript_intron_supporting_evidence.next_exon_id "
        "FROM "
        "transcript_intron_supporting_evidence "
        "WHERE "
        "transcript_intron_supporting_evidence."
        "transcript_id = %u "
        "AND "
        "transcript_intron_supporting_evidence."
        "intron_supporting_evidence_id = %u",
        ensTranscriptGetIdentifier(transcript),
        ensIntronsupportingevidenceGetIdentifier(ise));

    sqls = ensDatabaseadaptorSqlstatementNew(dba, statement);

    sqli = ajSqlrowiterNew(sqls);

    while (!ajSqlrowiterDone(sqli))
    {
        previousid = 0U;
        nextid     = 0U;

        sqlr = ajSqlrowiterGet(sqli);

        ajSqlcolumnToUint(sqlr, &previousid);
        ajSqlcolumnToUint(sqlr, &nextid);

        if (!*Previous)
        {
            *Previous = previousid;
            *Pnext    = nextid;
        }
    }

    ajSqlrowiterDel(&sqli);

    ensDatabaseadaptorSqlstatementDel(dba, &sqls);

    ajStrDel(&statement);

    return ajTrue;
}