LIB_EXPORT rc_t CC AlignMgrMakePlacementSetIterator ( struct AlignMgr const *self,
PlacementSetIterator **iter )
{
rc_t rc = 0;
if ( self == NULL )
rc = RC( rcAlign, rcIterator, rcConstructing, rcSelf, rcNull );
else
{
if ( iter == NULL )
rc = RC( rcAlign, rcIterator, rcConstructing, rcParam, rcNull );
else
{
PlacementSetIterator * psi = calloc( sizeof * psi, 1 );
if ( psi == NULL )
rc = RC( rcAlign, rcIterator, rcConstructing, rcMemory, rcExhausted );
else
{
rc = AlignMgrAddRef ( self );
if ( rc == 0 )
{
KRefcountInit( &psi->refcount, 1, "PlacementSetIterator", "Make", "align" );
psi->amgr = self;
psi->current_ref = NULL; /* we don't know that yet */
psi->current_window = NULL;
psi->current_entry = NULL;
DLListInit( &psi->pi_refs );
}
}
if ( rc == 0 )
*iter = psi;
else
free( psi );
}
}
return rc;
}
rc_t SRAMgrMake ( SRAMgr **mgrp,
const VDBManager *vmgr, const KDirectory *wd )
{
rc_t rc;
/* require sraschema object */
SRAMgr *mgr = malloc ( sizeof * mgr );
if ( mgr == NULL )
rc = RC ( rcSRA, rcMgr, rcConstructing, rcMemory, rcExhausted );
else
{
VSchema *schema;
rc = VDBManagerMakeSRASchema ( vmgr, & schema );
if ( rc == 0 )
{
rc = SRAMgrInitPath ( mgr, wd );
if ( rc == 0 )
{
KRefcountInit ( & mgr -> refcount, 1, "SRAMgr", "SRAMgrMake", "sramgr" );
mgr -> vmgr = vmgr;
mgr -> schema = schema;
mgr -> mode = kcmCreate; /* TBD - should this include parents? */
mgr -> read_only = true;
* mgrp = mgr;
return 0;
}
VSchemaRelease ( schema );
}
free ( mgr );
}
* mgrp = NULL;
return rc;
}
/* Make
*/
static
rc_t KRepositoryMake ( KRepository **rp, const KConfigNode *node,
const char *name, KRepCategory category, KRepSubCategory subcategory )
{
rc_t rc;
KRepository *r;
String name_str;
/* measure string */
StringInitCString ( & name_str, name );
/* create object */
r = malloc ( sizeof * r + name_str . size + 1 );
if ( r == NULL )
return RC ( rcKFG, rcNode, rcConstructing, rcMemory, rcExhausted );
rc = KConfigNodeAddRef ( node );
if ( rc != 0 )
{
free ( r );
return rc;
}
r -> node = node;
r -> name = name_str;
r -> name . addr = ( char* ) ( r + 1 );
KRefcountInit ( & r -> refcount, 1, "KRepository", "make", name );
r -> category = category;
r -> subcategory = subcategory;
memcpy ( r + 1, name, name_str . size );
( ( char* ) ( r + 1 ) ) [ name_str . size ] = 0;
* rp = r;
return 0;
}
LIB_EXPORT rc_t CC SRAMgrVCreateTable ( SRAMgr *self, SRATable **rslt,
const char *typespec, const char *spec, va_list args )
{
rc_t rc;
if ( rslt == NULL )
rc = RC ( rcSRA, rcTable, rcConstructing, rcParam, rcNull );
else
{
if ( self == NULL )
rc = RC ( rcSRA, rcTable, rcConstructing, rcSelf, rcNull );
else if ( spec == NULL )
rc = RC ( rcSRA, rcTable, rcConstructing, rcString, rcNull );
else if ( spec [ 0 ] == 0 )
rc = RC ( rcSRA, rcTable, rcConstructing, rcString, rcEmpty );
else
{
char path [ 4097 ];
size_t act_size = 0;
rc = string_vprintf(path, 4097, &act_size, spec, args);
path[act_size] = '\0';
if ( rc == 0 )
{
VTable *vtbl;
rc = VDBManagerCreateTable ( self -> vmgr, & vtbl, self -> schema,
typespec, ( self -> mode & kcmBitMask ) | kcmCreate, "%s", path );
if ( rc == 0 )
{
rc = VTableColumnCreateParams ( vtbl, kcmCreate, kcsCRC32, 0 );
if ( rc == 0 )
{
SRATable *tbl = calloc ( 1, sizeof * tbl );
if ( tbl == NULL )
rc = RC ( rcSRA, rcTable, rcConstructing, rcMemory, rcExhausted );
else
{
tbl -> vtbl = vtbl;
rc = VTableOpenMetadataUpdate ( vtbl, & tbl -> meta );
if ( rc == 0 )
rc = KMetadataVersion ( tbl -> meta, & tbl -> metavers );
if ( rc == 0 )
rc = VTableCreateCursorWrite ( vtbl, & tbl -> curs, kcmInsert );
if ( rc == 0 )
{
tbl -> mgr = SRAMgrAttach ( self );
tbl -> mode = self -> mode;
tbl -> read_only = false;
KRefcountInit ( & tbl -> refcount, 1, "SRATable", "OpenTableUpdate", path );
VectorInit ( & tbl -> wcol, 0, 16 );
* rslt = tbl;
return 0;
}
vtbl = NULL;
SRATableWhack ( tbl );
}
}
VTableRelease ( vtbl );
}
}
}
* rslt = NULL;
}
return rc;
}
/* OpenColumnWrite
* open a column for write
*
* "idx" [ OUT ] - return parameter for 1-based column index.
*
* "col" [ OUT, NULL OKAY ] - optional return parameter for
* newly opened column.
*
* "name" [ IN ] - NUL terminated string in UTF-8 giving column name
*
* "datatype" [ IN ] - NUL terminated string in ASCII
* describing fully qualified column data type
*/
LIB_EXPORT rc_t CC SRATableOpenColumnWrite ( SRATable *self,
uint32_t *idx, SRAColumn **col, const char *name, const char *datatype )
{
rc_t rc;
SRAColumn *rslt;
uint32_t ndx, cndx;
if (self == NULL)
return RC(RC_MODULE, RC_TARGET, rcOpening, rcSelf, rcNull);
if (name == NULL || idx == NULL)
return RC(RC_MODULE, RC_TARGET, rcOpening, rcParam, rcNull);
*idx = 0;
if (datatype && datatype[0])
{
SRADBG(("adding column (%s)%s\n", datatype, name));
rc = VCursorAddColumn(self->curs, &ndx, "(%s)%s", datatype, name);
}
else
{
SRADBG(("adding column %s\n", name));
rc = VCursorAddColumn(self->curs, &ndx, "%s", name);
}
if (rc != 0)
{
/* it's okay if the column is already there
any other rc is a hard error */
if (GetRCState ( rc ) != rcExists)
return rc;
if ( ! find_by_index(&self->wcol, ndx, &cndx) )
{
/* severe internal error */
return RC ( RC_MODULE, RC_TARGET, rcOpening, rcNoObj, rcNotFound );
}
/* get the uncounted reference to column from table */
rslt = VectorGet(&self->wcol, cndx);
}
else
{
VTypedecl type;
VTypedesc desc;
rslt = malloc(sizeof *rslt );
if (rslt == NULL)
return RC(RC_MODULE, rcColumn, rcConstructing, rcMemory, rcExhausted);
rc = VCursorDatatype(self->curs, ndx, &type, &desc);
if (rc == 0)
{
/* this object will sit uncounted within the table
when the table goes away, it will douse the columns
without regard to their reference count. see below */
KRefcountInit(&rslt->refcount, 0, "SRAColumn", "OpenColumnWrite", name);
/* the column has no reference to the table, so after this
there will only be an uncounted reference from table to column */
rslt->tbl = NULL;
rslt->idx = ndx;
rslt->read_only = false;
rslt->elem_bits = VTypedescSizeof(&desc);
rc = VectorAppend(&self->wcol, &cndx, rslt);
}
if ( rc != 0 )
{
free ( rslt );
return rc;
}
}
/* see if user wants a reference */
if ( col != NULL )
{
/* the first column reference exported will take
the refcount from zero to one */
SRAColumnAddRef ( rslt );
/* the first exported reference will need to be reflected
to the table. this will ensure that the table never tries
to whack its columns as long as they are held externally,
because the table itself will be kept alive. when the last
column reference is released, it will also release the table */
if ( rslt -> tbl == NULL )
rslt -> tbl = SRATableAttach ( self );
*col = rslt;
}
*idx = cndx + 1;
return rc;
}
LIB_EXPORT
rc_t CC
XFSTreeMake ( const struct XFSModel * Model, struct XFSTree ** Tree )
{
rc_t RCt;
struct XFSTree * tTree;
RCt = 0;
if ( Model == NULL || Tree == NULL ) {
return XFS_RC ( rcNull );
}
* Tree = NULL;
/* Creating a tree */
tTree = calloc ( 1, sizeof ( struct XFSTree ) );
/*
printf ( " |<- ThreeMake ( 0x%p )\n", ( void * ) tTree );
*/
if ( tTree == NULL ) {
return XFS_RC ( rcExhausted );
}
if ( XFS_StrDup (
XFSModelResource ( Model ),
& ( tTree -> Resource )
) != 0
) {
XFSTreeDispose ( tTree );
return XFS_RC ( rcExhausted );
}
if ( XFSModelVersion ( Model ) != NULL ) {
if ( XFS_StrDup (
XFSModelVersion ( Model ),
& ( tTree -> Version ) ) != 0
) {
XFSTreeDispose ( tTree );
return XFS_RC ( rcExhausted );
}
}
else {
tTree -> Version = NULL;
}
RCt = XFSNodeMake (
Model,
XFSModelNodeName ( XFSModelRootNode ( Model ) ),
NULL,
( const struct XFSNode ** ) & ( tTree -> Root )
);
if ( RCt == 0 ) {
KRefcountInit (
& ( tTree -> refcount ),
1,
_sXFSTree_classname,
"XFSTreeMake",
"Tree"
);
}
if ( RCt == 0 ) {
* Tree = tTree;
}
else {
XFSTreeDispose ( tTree );
tTree = NULL;
}
/*
printf ( " ->| ThreeMake ( 0x%p )\n", ( void * ) * Tree );
*/
return RCt;
} /* XFSTreeMake () */
/* MakeSet
* load a dynamic library
*
* "set" [ OUT ] - return parameter for lib set
*/
LIB_EXPORT rc_t CC KDyldMakeSet ( const KDyld *self, KDlset **setp )
{
rc_t rc = 0;
if ( setp == NULL )
rc = RC ( rcFS, rcDylib, rcConstructing, rcParam, rcNull );
else
{
if ( self == NULL )
rc = RC ( rcFS, rcDylib, rcConstructing, rcSelf, rcNull );
else
{
KDlset *set = malloc ( sizeof * set );
if ( set == NULL )
rc = RC ( rcFS, rcDylib, rcConstructing, rcMemory, rcExhausted );
else
{
set -> dl = KDyldAttach ( self );
VectorInit ( & set -> name, 0, 16 );
VectorInit ( & set -> ord, 0, 16 );
KRefcountInit ( & set -> refcount, 1, "KDlset", "make", "dlset" );
#if ! ALWAYS_ADD_EXE
{
KDylib *jni;
const char* libname = "vdb_jni.dll";
rc = KDyldLoadLib ( ( KDyld* ) self, & jni, libname );
if ( rc == 0 )
{
rc = KDlsetAddLib ( set, jni );
KDylibRelease ( jni );
}
/*if (rc == 0)*/ /* if JNI code is not there, C tools should not suffer */
{
* setp = set;
return 0;
}
}
#else
{
KDylib *exe;
rc = KDyldLoadLib ( ( KDyld* ) self, & exe, NULL );
if ( rc == 0 )
{
rc = KDlsetAddLib ( set, exe );
KDylibRelease ( exe );
if ( rc == 0 )
{
* setp = set;
return 0;
}
}
}
KDlsetRelease ( set );
#endif
}
}
* setp = NULL;
}
return rc;
}
LIB_EXPORT rc_t CC AlignMgrMakeAlignmentIterator ( struct AlignMgr const *self,
AlignmentIterator **iter,
bool copy,
INSDC_coord_zero ref_pos,
INSDC_coord_len ref_len,
const INSDC_4na_bin *read,
INSDC_coord_len read_len,
const bool *has_mismatch,
const bool *has_ref_offset,
const int32_t *ref_offset,
uint32_t ref_offset_len,
INSDC_coord_zero ref_window_start,
INSDC_coord_len ref_window_len )
{
rc_t rc = 0;
if ( self == NULL )
rc = RC( rcAlign, rcIterator, rcConstructing, rcSelf, rcNull );
else
{
if ( iter == NULL || has_mismatch == NULL || has_ref_offset == NULL ||
read == NULL || read_len == 0 )
rc = RC( rcAlign, rcIterator, rcConstructing, rcParam, rcNull );
else
{
AlignmentIterator * ali = NULL;
size_t po_size = ( ( sizeof *(ali->pos_ofs) ) * ( ref_offset_len ) );
size_t full_size = ( sizeof *ali ) + ( read_len * 2 ) + po_size;
uint8_t * ptr = calloc( full_size, 1 );
*iter = NULL;
if ( ptr == NULL )
rc = RC( rcAlign, rcIterator, rcConstructing, rcMemory, rcExhausted );
else
{
ali = ( AlignmentIterator * )ptr;
ptr += ( sizeof *ali );
KRefcountInit( &ali->refcount, 1, "AlignmentIterator", "Make", "align" );
/* copy HAS_MISMATCH into place, point the header-value to it, advance */
memcpy( ptr, has_mismatch, read_len );
ali->has_mismatch = (bool *)ptr;
ptr += read_len;
/* copy READ into place, point the header-value to it, advance */
memcpy( ptr, read, read_len );
ali->read = ( INSDC_4na_bin * )ptr;
ptr += read_len;
ali->read_len = read_len;
ali->ref_len = ref_len;
ali->abs_ref_start = ref_pos;
ali->pos_ofs = (pos_offset *)ptr;
ali->ref_window_start = ref_window_start;
ali->ref_window_len = ref_window_len;
ali->free_on_whack = true;
rc = compute_posofs( ali, has_ref_offset, ref_offset, ref_offset_len );
if ( ali->pos_ofs_idx == 0 )
al_iter_adjust_next( ali );
if ( rc == 0 )
{
rc = AlignMgrAddRef ( self );
if ( rc == 0 )
ali->amgr = self;
}
}
if ( rc == 0 )
*iter = ali;
else
free( ali );
}
}
return rc;
}
LIB_EXPORT rc_t CC AlignIteratorRecordPopulate ( void *obj,
const PlacementRecord *placement, struct VCursor const *curs,
INSDC_coord_zero ref_window_start, INSDC_coord_len ref_window_len, void *data )
{
/* read the data required to build a Alignment-Iterator,
then create the Alignment-Iterator into the already allocated memory */
const void * base;
const void * base_has_ref_offset;
const void * base_ref_offset;
INSDC_coord_len data_len;
uint32_t ref_offset_len;
rc_t rc;
AlignmentIterator *iter = ( AlignmentIterator * ) obj;
AlignMgr *almgr = ( AlignMgr * ) data;
uint8_t * ptr = ( void* ) iter;
ptr += ( sizeof *iter );
rc = get_idx_and_read( curs, COL_HAS_MISMATCH, placement->id, &base, &data_len );
if ( rc == 0 )
{
/* copy HAS_MISMATCH into place, point the header-value to it, advance */
memcpy( ptr, base, data_len );
iter->has_mismatch = (bool *)ptr;
ptr += data_len;
}
if ( rc == 0 )
{
rc = get_idx_and_read( curs, COL_READ, placement->id, &base, &data_len );
/* copy READ into place, point the header-value to it, advance */
if ( rc == 0 )
{
memcpy( ptr, base, data_len );
iter->read = ( INSDC_4na_bin * )ptr;
iter->read_len = data_len;
iter->abs_ref_start = placement->pos;
iter->ref_len = placement->len;
iter->rel_ref_pos = 0;
iter->seq_pos = 0;
ptr += data_len;
iter->pos_ofs = (pos_offset *)ptr;
iter->ref_window_start = ref_window_start;
iter->ref_window_len = ref_window_len;
iter->free_on_whack = false;
}
}
if ( rc == 0 )
{
rc = get_idx_and_read( curs, COL_HAS_REF_OFFSET, placement->id, &base_has_ref_offset, &data_len );
}
if ( rc == 0 )
{
rc = get_idx_and_read( curs, COL_REF_OFFSET, placement->id, &base_ref_offset, &ref_offset_len );
}
if ( rc == 0 )
{
rc = compute_posofs( iter,
( const bool * )base_has_ref_offset,
( const int32_t * )base_ref_offset,
ref_offset_len );
}
if ( rc == 0 )
{
if ( iter->pos_ofs_idx == 0 )
al_iter_adjust_next( iter );
KRefcountInit( &iter->refcount, 1, "AlignmentIterator", "Make", "align" );
data_len = 0;
while( ( iter->abs_ref_start + iter->rel_ref_pos ) < ref_window_start && rc == 0 )
{
rc = AlignmentIteratorNext ( iter );
data_len++;
}
}
if ( rc == 0 ) { rc = AlignMgrAddRef ( almgr ); }
if ( rc == 0 ) { iter->amgr = almgr; }
/*
if ( rc == 0 )
{
OUTMSG(( "placement[%lu] at %u (w=%u) next(%u) \n",
placement->id, iter->abs_ref_start, ref_window_start, data_len ));
}
*/
return rc;
}
static
rc_t CC
_KartItemMake (
struct XFSGapKartItem ** RetItem,
const struct KartItem * Item
)
{
rc_t RCt;
const struct String * TheString;
struct XFSGapKartItem * xItem;
uint64_t ProjectId, ObjectId;
RCt = 0;
TheString = NULL;
xItem = NULL;
ProjectId = ObjectId = 0;
XFS_CSAN ( RetItem )
XFS_CAN ( RetItem )
XFS_CAN ( Item )
xItem = calloc ( 1, sizeof ( struct XFSGapKartItem ) );
if ( xItem == NULL ) {
return XFS_RC ( rcExhausted );
}
KRefcountInit (
& ( xItem -> refcount ),
1,
_sXFSGapKartItem_classname,
"_KartItemMake",
"KartItem"
);
RCt = KartItemProjIdNumber ( Item, & ProjectId );
if ( RCt == 0 ) {
xItem -> project_id = ( uint32_t ) ProjectId;
}
if ( RCt == 0 ) {
RCt = KartItemItemId ( Item, & TheString );
if ( RCt == 0 && TheString -> len != 0 ) {
RCt = KartItemItemIdNumber ( Item, & ObjectId );
if ( RCt == 0 ) {
xItem -> object_id = ( uint32_t ) ObjectId;
}
}
else {
xItem -> object_id = 0;
}
}
if ( RCt == 0 ) {
RCt = KartItemAccession ( Item, & TheString );
if ( RCt == 0 && TheString -> len != 0 ) {
RCt = XFS_SStrDup ( TheString, & xItem -> accession );
}
else {
xItem -> accession = NULL;
}
}
if ( RCt == 0 ) {
RCt = KartItemName ( Item, & TheString );
if ( RCt == 0 && TheString -> len != 0 ) {
RCt = XFS_SStrDup ( TheString, & xItem -> name );
}
else {
xItem -> name = NULL;
}
}
if ( RCt == 0 ) {
RCt = KartItemItemDesc ( Item, & TheString );
if ( RCt == 0 && TheString -> len != 0 ) {
RCt = XFS_SStrDup ( TheString, & xItem -> description );
}
else {
xItem -> description = NULL;
}
}
if ( xItem -> object_id == 0 && xItem -> accession == NULL ) {
RCt = XFS_RC ( rcInvalid );
}
if ( RCt == 0 ) {
* RetItem = xItem;
}
else {
if ( xItem != NULL ) {
_KartItemDispose ( xItem );
}
}
return RCt;
} /* _KartItemMake () */
/* OpenRead
* open an existing table
*
* "tbl" [ OUT ] - return parameter for table
*
* "spec" [ IN ] - NUL terminated UTF-8 string giving path
* to table.
*/
static
rc_t CC SRAMgrVOpenAltTableRead ( const SRAMgr *self,
const SRATable **rslt, const char *altname, const char *spec, va_list args )
{
rc_t rc;
if ( rslt == NULL )
rc = RC ( rcSRA, rcTable, rcOpening, rcParam, rcNull );
else
{
if ( self == NULL )
rc = RC ( rcSRA, rcMgr, rcAccessing, rcSelf, rcNull );
else if ( spec == NULL )
rc = RC ( rcSRA, rcTable, rcOpening, rcName, rcNull );
else if ( spec [ 0 ] == 0 )
rc = RC ( rcSRA, rcTable, rcOpening, rcName, rcEmpty );
else
{
char path [ 4096 ];
rc = ResolveTablePath ( self, path, sizeof path, spec, args );
if ( rc == 0 )
{
SRATable *tbl = calloc ( 1, sizeof *tbl );
if ( tbl == NULL )
rc = RC ( rcSRA, rcTable, rcConstructing, rcMemory, rcExhausted );
else
{
VSchema *schema = NULL;
rc = VDBManagerMakeSRASchema(self -> vmgr, & schema);
if ( rc == 0 )
{
rc = VDBManagerOpenTableRead ( self -> vmgr, & tbl -> vtbl, schema, path );
if ( rc != 0 && GetRCObject ( rc ) == rcTable && GetRCState ( rc ) == rcIncorrect )
{
const VDatabase *db;
rc_t rc2 = VDBManagerOpenDBRead ( self -> vmgr, & db, schema, path );
if ( rc2 == 0 )
{
rc2 = VDatabaseOpenTableRead ( db, & tbl -> vtbl, altname );
if ( rc2 == 0 )
rc = 0;
VDatabaseRelease ( db );
}
}
VSchemaRelease(schema);
if ( rc == 0 )
{
rc = VTableOpenMetadataRead ( tbl -> vtbl, & tbl -> meta );
if ( rc == 0 )
{
rc = KMetadataVersion ( tbl -> meta, & tbl -> metavers );
if ( rc == 0 )
{
rc = VTableCreateCursorRead ( tbl -> vtbl, & tbl -> curs );
if ( rc == 0 )
{
tbl -> mgr = SRAMgrAttach ( self );
tbl -> mode = self -> mode;
tbl -> read_only = true;
KRefcountInit ( & tbl -> refcount, 1, "SRATable", "OpenTableRead", path );
rc = SRATableFillOut ( tbl, false );
if ( rc == 0 )
{
* rslt = tbl;
return 0;
}
}
}
}
}
}
SRATableWhack ( tbl );
}
}
}
* rslt = NULL;
}
return rc;
}
