static AsnIoPtr AsnIoFromOutputStream (OutputStreamPtr osp)
{
AsnIoPtr aip;
Char file [FILENAME_MAX], path [PATH_MAX];
CharPtr write_flag;
if (osp == NULL) return NULL;
if (osp->aip == NULL) {
write_flag = osp->is_binary ? "wb" : "w";
if (StringDoesHaveText (osp->outfile)) {
StringNCpy_0 (path, osp->outfile, sizeof (path));
} else {
if (osp->base == NULL) {
aip = AsnIoOpen ("stdout", write_flag);
} else {
if (osp->outsuffix == NULL) {
osp->outsuffix = "";
}
StringNCpy_0 (path, osp->results_dir, sizeof (path));
sprintf (file, "%s%s%s", osp->base, osp->suffix, osp->outsuffix);
FileBuildPath (path, NULL, file);
aip = AsnIoOpen (path, write_flag);
if (aip == NULL) {
Message (MSG_POSTERR, "Unable to write to %s.", path);
}
}
}
} else {
aip = osp->aip;
}
return aip;
}
NLM_EXTERN CONN QUERY_OpenServiceQueryEx (
const char* service,
const char* parameters,
Nlm_Uint4 timeoutsec,
const char* arguments
)
{
CONN conn;
CONNECTOR connector;
SConnNetInfo* net_info;
size_t n_written;
EIO_Status status;
/* fill in connection info fields and create the connection */
net_info = ConnNetInfo_Create (service);
ASSERT ( net_info );
/* let the user agent be set with a program name */
x_SetupUserHeader (net_info,
NULL, eMIME_T_Unknown, eMIME_Unknown, eENCOD_None);
if (timeoutsec == (Nlm_Uint4)(-1L)) {
net_info->timeout = kInfiniteTimeout;
} else if ( timeoutsec ) {
net_info->tmo.sec = timeoutsec;
net_info->tmo.usec = timeoutsec;
net_info->timeout = &net_info->tmo;
}
ConnNetInfo_PostOverrideArg (net_info, arguments, 0);
connector = SERVICE_CreateConnectorEx (service, fSERV_Any, net_info, 0);
ConnNetInfo_Destroy (net_info);
if (connector == NULL) {
ErrPostEx (SEV_ERROR, 0, 0, "QUERY_OpenServiceQuery failed in SERVICE_CreateConnectorEx");
conn = NULL;
} else if ((status = CONN_Create (connector, &conn)) != eIO_Success) {
ErrPostEx (SEV_ERROR, 0, 0, "QUERY_OpenServiceQuery failed in CONN_Create:"
" %s", IO_StatusStr (status));
ASSERT (conn == NULL);
} else if (StringDoesHaveText (parameters)) {
status = CONN_Write (conn, parameters, StringLen (parameters),
&n_written, eIO_WritePersist);
if (status != eIO_Success) {
ErrPostEx (SEV_ERROR, 0, 0, "QUERY_OpenServiceQuery failed to write service parameters in CONN_Write: %s", IO_StatusStr (status));
CONN_Close (conn);
conn = NULL;
}
}
return conn;
}
NLM_EXTERN Boolean PrintTemplateSetLoadEx ( CharPtr path, CharPtr localStr )
{
Boolean verbose = TRUE;
if (StringDoesHaveText (localStr)) {
verbose = FALSE;
}
if (PrintTemplateSetLoadInt (path, verbose)) return TRUE;
if (verbose) return FALSE;
return LoadObjPrtFromLocalString (localStr);
}
static CharPtr PrintBadgTable (
DoC d,
Int2 item,
Pointer data
)
{
Char buf [256];
IntBadgPtr ibp;
Int2 reason;
SscBadgPtr sbp;
sbp = (SscBadgPtr) GetObjectExtra (d);
if (sbp == NULL || item < 1 || item > 127) return NULL;
ibp = GetBadgInfo (sbp, item);
if (ibp == NULL) return NULL;
buf [0] = '\0';
if (StringDoesHaveText (ibp->name)) {
StringCat (buf, ibp->name);
} else {
StringCat (buf, " ");
}
StringCat (buf, "\t");
reason = (Int2) ibp->reason;
if (reason > 0 && reason <= 18) {
StringCat (buf, reasonLabel [reason]);
} else {
StringCat (buf, " ");
}
StringCat (buf, "\n");
return StringSave (buf);
}
/* Set HTTP user header */
static void x_SetupUserHeader (
SConnNetInfo* net_info,
const char* appName,
EMIME_Type type,
EMIME_SubType subtype,
EMIME_Encoding encoding
)
{
const char* userAgentName = NULL;
char user_header [MAX_CONTENT_TYPE_LEN + 80];
/* content-type if specified */
if (type < eMIME_T_Unknown) {
VERIFY( MIME_ComposeContentTypeEx (type, subtype, encoding,
user_header, MAX_CONTENT_TYPE_LEN) );
ConnNetInfo_OverrideUserHeader (net_info, user_header);
}
/* allow the user to specify a prog. name, otherwise get it from elsewhere */
if (StringHasNoText (appName)) {
const char* progName = GetProgramName();
if (StringHasNoText (progName)) {
char path [PATH_MAX];
Nlm_ProgramPath (path, sizeof (path));
userAgentName = StringRChr (path, DIRDELIMCHR);
if (userAgentName)
++userAgentName;
} else
userAgentName = progName;
} else
userAgentName = appName;
if (StringDoesHaveText (userAgentName)) {
sprintf (user_header, "User-Agent: %.80s\r\n", userAgentName);
ConnNetInfo_ExtendUserHeader (net_info, user_header);
}
}
Int2 Main(void)
{
Char app [64];
CharPtr directory;
CharPtr ptr;
Char sfx [32];
OutputStreamData osd;
InputStreamData isd;
AsnStreamData asd;
Int4 gap_sizes[2];
Int4 rval = 0;
Int4 u_eq = 0, u_gteq = -1, k_eq = 0, k_gteq = -1;
/* standard setup */
ErrSetFatalLevel (SEV_MAX);
ErrClearOptFlags (EO_SHOW_USERSTR);
UseLocalAsnloadDataAndErrMsg ();
ErrPathReset ();
/* finish resolving internal connections in ASN.1 parse tables */
if (! AllObjLoad ()) {
Message (MSG_FATAL, "AllObjLoad failed");
return 1;
}
if (! SubmitAsnLoad ()) {
Message (MSG_FATAL, "SubmitAsnLoad failed");
return 1;
}
if (! FeatDefSetLoad ()) {
Message (MSG_FATAL, "FeatDefSetLoad failed");
return 1;
}
if (! SeqCodeSetLoad ()) {
Message (MSG_FATAL, "SeqCodeSetLoad failed");
return 1;
}
if (! GeneticCodeTableLoad ()) {
Message (MSG_FATAL, "GeneticCodeTableLoad failed");
return 1;
}
SetUpAsnStreamData (&asd);
/* initialize OuputStreamData */
MemSet (&osd, 0, sizeof (osd));
/* initialize InputStreamData */
MemSet (&isd, 0, sizeof (isd));
/* initialize gap_sizes */
gap_sizes[0] = 0;
gap_sizes[1] = 0;
/* process command line arguments */
sprintf (app, "raw2delt %s", RAW2DELT_APPLICATION);
if (! GetArgs (app, sizeof (myargs) / sizeof (Args), myargs)) {
return 0;
}
u_eq = (Int4) myargs [u_argEqUnknownGap].intvalue;
u_gteq = (Int4) myargs [U_argGTEqUnknownGap].intvalue;
k_eq = (Int4) myargs [k_argEqUnknownGap].intvalue;
k_gteq = (Int4) myargs [K_argGtEqUnknownGap].intvalue;
if (u_eq < 1 && u_gteq < 1 && k_eq < 1 && k_gteq < 1) {
Message (MSG_FATAL, "Must specify values for at least one of -u, -U, -k, -K");
return 1;
} else if (u_eq > -1 && u_gteq > -1) {
Message (MSG_FATAL, "May only specify value for -u or -U, not both");
return 1;
} else if (k_eq > -1 && k_gteq > -1) {
Message (MSG_FATAL, "May only specify value for -k or -K, not both");
return 1;
}
if (u_eq > 0) {
gap_sizes[0] = u_eq;
} else if (u_gteq > 0) {
gap_sizes[0] = 0 - u_gteq;
}
if (k_eq > 0) {
gap_sizes[1] = k_eq;
} else if (k_gteq > 0) {
gap_sizes[1] = 0 - k_gteq;
}
if (gap_sizes[0] == gap_sizes[1]) {
Message (MSG_FATAL, "Cannot specify the same size for known and unknown length gaps");
return 1;
}
directory = (CharPtr) myargs [p_argInputPath].strvalue;
osd.results_dir = (CharPtr) myargs [r_argOutputPath].strvalue;
if (StringHasNoText (osd.results_dir)) {
osd.results_dir = NULL;
}
osd.suffix = (CharPtr) myargs [x_argSuffix].strvalue;
osd.outsuffix = (CharPtr) myargs [s_argOutSuffix].strvalue;
osd.base = (CharPtr) myargs [i_argInputFile].strvalue;
osd.outfile = (CharPtr) myargs [o_argOutputFile].strvalue;
if (StringHasNoText (osd.outfile)) {
osd.outfile = NULL;
}
osd.is_binary = (Boolean) myargs [d_argOutputBinary].intvalue;
if (osd.base == "stdin") {
osd.base = NULL;
}
/* if we don't have an output directory or an output file, and the user hasn't provided an
* output suffix, add a default.
*/
if (osd.results_dir == NULL && osd.outfile == NULL && StringHasNoText (osd.outsuffix)) {
osd.outsuffix = ".delta";
}
isd.is_binary = (Boolean) myargs [b_argInputBinary].intvalue;
isd.is_seqentry = (Boolean) myargs [e_argInputSeqEntry].intvalue;
isd.directory = directory;
isd.base = osd.base;
isd.suffix = osd.suffix;
if (StringDoesHaveText (osd.outfile)) {
osd.aip = AsnIoOpen (osd.outfile, "w");
if (osd.aip == NULL) {
Message (MSG_FATAL, "Unable to open output file");
return 1;
}
} else {
if (StringHasNoText (osd.results_dir)) {
osd.results_dir = directory;
}
/* if we're putting the results in a separate directory, strip the directory name from the output base */
if (!StringHasNoText (osd.results_dir) && !StringHasNoText (osd.base)) {
#ifdef OS_MSWIN
ptr = StringRChr (osd.base, '\\');
#else
ptr = StringRChr (osd.base, '/');
#endif;
if (ptr != NULL) {
osd.base = ptr + 1;
}
}
}
if (StringHasNoText(directory) && StringHasNoText(osd.base)) {
rval = ProcessStream (&isd, &osd, &asd, gap_sizes);
} else if (StringDoesHaveText (osd.base)) {
ptr = StringRChr (osd.base, '.');
sfx[0] = '\0';
if (ptr != NULL) {
StringNCpy_0 (sfx, ptr, sizeof (sfx));
*ptr = '\0';
}
osd.suffix = sfx;
isd.suffix = sfx;
if (isd.is_binary) {
rval = ProcessStream (&isd, &osd, &asd, gap_sizes);
} else {
rval = ProcessOneRecord (directory, &osd, gap_sizes);
}
} else {
rval = FileRecurse (directory, &isd, &osd, &asd, gap_sizes);
}
if (osd.aip != NULL) {
AsnIoFlush (osd.aip);
AsnIoClose (osd.aip);
}
return rval;
}
/* return -1 on failure, 0 on success */
static Int4 FileRecurse (
CharPtr directory,
InputStreamPtr isp,
OutputStreamPtr osp,
AsnStreamPtr asp,
Int4Ptr gap_sizes
)
{
Char path [PATH_MAX];
CharPtr ptr;
CharPtr str;
ValNodePtr head, vnp;
CharPtr orig_dir, orig_base;
Int4 rval = 0;
/* get list of all files in source directory */
head = DirCatalog (directory);
for (vnp = head; vnp != NULL; vnp = vnp->next) {
if (vnp->choice == 0) {
str = (CharPtr) vnp->data.ptrvalue;
if (StringDoesHaveText (str)) {
/* does filename have desired substring? */
ptr = StringStr (str, osp->suffix);
if (ptr != NULL) {
/* make sure detected suffix is really at end of filename */
if (StringCmp (ptr, osp->suffix) == 0) {
*ptr = '\0';
/* process file that has desired suffix (usually .fsa) */
osp->base = str;
orig_dir = isp->directory;
isp->directory = directory;
orig_base = isp->base;
isp->base = str;
if (isp->is_binary) {
rval |= ProcessStream (isp, osp, asp, gap_sizes);
} else {
rval |= ProcessOneRecord (directory, osp, gap_sizes);
}
isp->directory = orig_dir;
isp->base = orig_base;
osp->base = NULL;
}
}
}
} else if (vnp->choice == 1) {
/* recurse into subdirectory */
StringNCpy_0 (path, directory, sizeof (path));
str = (CharPtr) vnp->data.ptrvalue;
FileBuildPath (path, str, NULL);
rval |= FileRecurse (path, isp, osp, asp, gap_sizes);
}
}
/* clean up file list */
ValNodeFreeData (head);
return rval;
}
Int2 Main (void)
{
Char app [64], type;
CSpeedFlagData cfd;
CharPtr directory, filter, infile, logfile, outfile, str, suffix;
Boolean remote;
time_t runtime, starttime, stoptime;
/* standard setup */
ErrSetFatalLevel (SEV_MAX);
ErrClearOptFlags (EO_SHOW_USERSTR);
UseLocalAsnloadDataAndErrMsg ();
ErrPathReset ();
/* finish resolving internal connections in ASN.1 parse tables */
if (! AllObjLoad ()) {
Message (MSG_FATAL, "AllObjLoad failed");
return 1;
}
if (! SubmitAsnLoad ()) {
Message (MSG_FATAL, "SubmitAsnLoad failed");
return 1;
}
if (! FeatDefSetLoad ()) {
Message (MSG_FATAL, "FeatDefSetLoad failed");
return 1;
}
if (! SeqCodeSetLoad ()) {
Message (MSG_FATAL, "SeqCodeSetLoad failed");
return 1;
}
if (! GeneticCodeTableLoad ()) {
Message (MSG_FATAL, "GeneticCodeTableLoad failed");
return 1;
}
/* process command line arguments */
sprintf (app, "cspeedtest %s", CSPEEDTEST_APPLICATION);
if (! GetArgs (app, sizeof (myargs) / sizeof (Args), myargs)) {
return 0;
}
MemSet ((Pointer) &cfd, 0, sizeof (CSpeedFlagData));
directory = (CharPtr) myargs [p_argInputPath].strvalue;
infile = (CharPtr) myargs [i_argInputFile].strvalue;
outfile = (CharPtr) myargs [o_argOutputFile].strvalue;
filter = (CharPtr) myargs [f_argFilter].strvalue;
suffix = (CharPtr) myargs [x_argSuffix].strvalue;
cfd.batch = FALSE;
cfd.binary = (Boolean) myargs [b_argBinary].intvalue;
cfd.compressed = (Boolean) myargs [c_argCompressed].intvalue;
cfd.lock = (Boolean) myargs [l_argLockFar].intvalue;
cfd.type = 1;
str = myargs [a_argType].strvalue;
TrimSpacesAroundString (str);
if (StringDoesHaveText (str)) {
type = str [0];
} else {
type = 'a';
}
type = TO_LOWER (type);
switch (type) {
case 'a' :
cfd.type = 1;
break;
case 'e' :
cfd.type = 2;
break;
case 'b' :
cfd.type = 3;
break;
case 's' :
cfd.type = 4;
break;
case 'm' :
cfd.type = 5;
break;
case 't' :
cfd.type = 1;
cfd.batch = TRUE;
break;
case 'f' :
cfd.type = 6;
break;
case 'l' :
cfd.type = 7;
break;
default :
cfd.type = 1;
break;
}
remote = (Boolean) myargs [R_argRemote].intvalue;
cfd.maxcount = myargs [X_argMaxCount].intvalue;
if (cfd.maxcount < 1) {
cfd.maxcount = 1;
}
cfd.io = myargs [O_argInOut].strvalue;
cfd.clean = myargs [K_argClean].strvalue;
cfd.skip = myargs [P_argSkip].strvalue;
cfd.index = myargs [I_argIndex].strvalue;
cfd.seq = myargs [S_argSeq].strvalue;
cfd.feat = myargs [F_argFeat].strvalue;
cfd.desc = myargs [D_argDesc].strvalue;
cfd.verify = myargs [V_argVerify].strvalue;
cfd.amp = AsnAllModPtr ();
cfd.atp_bss = AsnFind ("Bioseq-set");
cfd.atp_bsss = AsnFind ("Bioseq-set.seq-set");
cfd.atp_se = AsnFind ("Bioseq-set.seq-set.E");
cfd.atp_bsc = AsnFind ("Bioseq-set.class");
cfd.bssp_atp = AsnLinkType (NULL, cfd.atp_bss);
logfile = (CharPtr) myargs [L_argLogFile].strvalue;
if (StringDoesHaveText (logfile)) {
cfd.logfp = FileOpen (logfile, "w");
}
if (remote) {
PubSeqFetchEnable ();
}
if (StringDoesHaveText (outfile)) {
cfd.ofp = FileOpen (outfile, "w");
}
starttime = GetSecs ();
if (StringDoesHaveText (directory)) {
DirExplore (directory, NULL, suffix, FALSE, ProcessOneRecord, (Pointer) &cfd);
} else if (StringDoesHaveText (infile)) {
ProcessOneRecord (infile, (Pointer) &cfd);
}
if (cfd.ofp != NULL) {
FileClose (cfd.ofp);
}
stoptime = GetSecs ();
runtime = stoptime - starttime;
if (cfd.logfp != NULL) {
fprintf (cfd.logfp, "Finished in %ld seconds\n", (long) runtime);
FileClose (cfd.logfp);
}
printf ("Finished in %ld seconds\n", (long) runtime);
if (remote) {
PubSeqFetchDisable ();
}
return 0;
}
NLM_EXTERN CONN QUERY_OpenUrlQuery (
const char* host_machine,
Nlm_Uint2 host_port,
const char* host_path,
const char* arguments,
const char* appName,
Nlm_Uint4 timeoutsec,
EMIME_Type type,
EMIME_SubType subtype,
EMIME_Encoding encoding,
THCC_Flags flags
)
{
CONN conn;
CONNECTOR connector;
SConnNetInfo* net_info;
EIO_Status status;
if (StringHasNoText (host_path))
return NULL;
/* fill in connection info fields and create the connection */
net_info = ConnNetInfo_Create(0);
ASSERT ( net_info );
x_SetupUserHeader (net_info, appName, type, subtype, encoding);
if (StringDoesHaveText (host_machine)) {
StringNCpy_0 (net_info->host, host_machine, sizeof (net_info->host));
}
if ( host_port ) {
net_info->port = host_port;
}
StringNCpy_0 (net_info->path, host_path, sizeof (net_info->path));
if (StringDoesHaveText (arguments)) {
StringNCpy_0 (net_info->args, arguments, sizeof (net_info->args));
}
if (timeoutsec == (Nlm_Uint4)(-1L)) {
net_info->timeout = kInfiniteTimeout;
} else if ( timeoutsec ) {
net_info->tmo.sec = timeoutsec;
net_info->tmo.usec = timeoutsec;
net_info->timeout = &net_info->tmo;
}
connector = HTTP_CreateConnector (net_info, NULL, flags);
ConnNetInfo_Destroy (net_info);
if (connector == NULL) {
ErrPostEx (SEV_ERROR, 0, 0, "QUERY_OpenUrlQuery failed in HTTP_CreateConnector");
conn = NULL;
} else if ((status = CONN_Create (connector, &conn)) != eIO_Success) {
ErrPostEx (SEV_ERROR, 0, 0, "QUERY_OpenUrlQuery failed in CONN_Create: %s",
IO_StatusStr (status));
ASSERT (conn == NULL);
}
return conn;
}
