bool CAuthor::x_GetLabelV2(string* label, TLabelFlags flags, CTempString name,
CTempString initials, CTempString suffix)
{
if (name.empty()) {
return false;
}
if (name.size() <= 6 && (SWNC(name, "et al") || SWNC(name, "et,al"))) {
name = "et al.";
if (NStr::EndsWith(*label, " and ")) {
label->replace(label->size() - 5, NPOS, ", ");
}
}
SIZE_TYPE pos = label->size();
*label += name;
if (HasText(initials)) {
*label += ',';
*label += initials;
}
if (HasText(suffix)) {
*label += ' ';
*label += suffix;
}
if ((flags & fLabel_FlatEMBL) != 0) {
NStr::ReplaceInPlace(*label, ",", " ", pos);
}
return true;
}
CJsonNode CJsonNode::GuessType(const CTempString& value)
{
const char* ch = value.begin();
const char* end = value.end();
switch (*ch) {
case '"':
case '\'':
return NewStringNode(NStr::ParseQuoted(value));
case '-':
if (++ch >= end || !isdigit(*ch))
return NewStringNode(value);
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
do
if (++ch >= end)
return NewIntegerNode(NStr::StringToInt8(value));
while (isdigit(*ch));
switch (*ch) {
case '.':
if (++ch == end || !isdigit(*ch))
return NewStringNode(value);
for (;;) {
if (++ch == end)
return NewDoubleNode(NStr::StringToDouble(value));
if (!isdigit(*ch)) {
if (*ch == 'E' || *ch == 'e')
break;
return NewStringNode(value);
}
}
/* FALL THROUGH */
case 'E':
case 'e':
if (++ch < end && (*ch == '-' || *ch == '+' ?
++ch < end && isdigit(*ch) : isdigit(*ch)))
do
if (++ch == end)
return NewDoubleNode(NStr::StringToDouble(value));
while (isdigit(*ch));
/* FALL THROUGH */
default:
return NewStringNode(value);
}
}
return NStr::CompareNocase(value, "false") == 0 ? NewBooleanNode(false) :
NStr::CompareNocase(value, "true") == 0 ? NewBooleanNode(true) :
NStr::CompareNocase(value, "none") == 0 ? NewNullNode() :
NewStringNode(value);
}
CBlastDbBlob::CBlastDbBlob(CTempString data, bool copy)
: m_Owner(copy), m_ReadOffset(0), m_WriteOffset(0)
{
if (m_Owner) {
m_DataHere.assign(data.data(), data.data() + data.size());
} else {
m_DataRef = data;
}
}
CTempString CShortReadFastaInputSource::x_ParseDefline(CTempString& line)
{
// set local sequence id for the new sequence as the string between '>'
// and the first space
size_t begin = 1;
size_t end = line.find(' ', 1);
CTempString id = line.substr(begin, end - begin);
return id;
}
void CRequestContext::x_UpdateStdContextProp(CTempString name) const
{
CRequestContext& ctx = const_cast<CRequestContext&>(*this);
bool match = NStr::EqualNocase(name, kPassThrough_Sid);
if (name.empty() || match) {
if (x_IsSetPassThroughProp(kPassThrough_Sid, false)) {
ctx.SetSessionID(x_GetPassThroughProp(kPassThrough_Sid, false));
}
// Reset property only if explicit name is provided
else if ( match ) {
ctx.UnsetSessionID();
}
// Explicit name provided - skip other checks.
if ( match ) return;
}
match = NStr::EqualNocase(name, kPassThrough_Phid);
if (name.empty() || match) {
if (x_IsSetPassThroughProp(kPassThrough_Phid, false)) {
ctx.SetHitID(x_GetPassThroughProp(kPassThrough_Phid, false));
}
// Reset property only if explicit name is provided
else if ( match ) {
ctx.UnsetHitID();
}
// Explicit name provided - skip other checks.
if ( match ) return;
}
match = NStr::EqualNocase(name, kPassThrough_ClientIp);
if (name.empty() || match) {
if (x_IsSetPassThroughProp(kPassThrough_ClientIp, false)) {
ctx.SetClientIP(x_GetPassThroughProp(kPassThrough_ClientIp, false));
}
// Reset property only if explicit name is provided
else if ( match ) {
ctx.UnsetClientIP();
}
// Explicit name provided - skip other checks.
if ( match ) return;
}
match = NStr::EqualNocase(name, kPassThrough_Dtab);
if (name.empty() || match) {
if (x_IsSetPassThroughProp(kPassThrough_Dtab, false)) {
ctx.SetDtab(x_GetPassThroughProp(kPassThrough_Dtab, false));
}
// Reset property only if explicit name is provided
else if ( match ) {
ctx.UnsetDtab();
}
// Explicit name provided - skip other checks.
if ( match ) return;
}
}
void CVDBCursor::SetParam(const char* name, const CTempString& value) const
{
if ( rc_t rc = VCursorParamsSet
((struct VCursorParams *)GetPointer(),
name, "%.*s", value.size(), value.data()) ) {
NCBI_THROW2_FMT(CSraException, eNotFound,
"Cannot set VDB cursor param: "<<*this<<": "<<name,
rc);
}
}
void CTL_BCPInCmd::SetHints(CTempString hints)
{
#ifdef FTDS_IN_USE
m_Hints.clear();
if (Check(blk_sethints(x_GetSybaseCmd(), (CS_CHAR*)hints.data(), CS_INT(hints.size()))) == CS_FAIL) {
DATABASE_DRIVER_ERROR("blk_sethints failed." + GetDbgInfo(), 123018);
}
#else
_ASSERT(false);
#endif
}
static bool IsInteger(const CTempString& value)
{
if (value.empty())
return false;
const char* digit = value.end();
while (--digit > value.begin())
if (!isdigit(*digit))
return false;
return isdigit(*digit) || (*digit == '-' && value.length() > 1);
}
bool g_FixMisplacedPID(CJsonNode& stat_info, CTempString& executable_path,
const char* pid_key)
{
SIZE_TYPE misplaced_pid = NStr::Find(executable_path, "; PID: ");
if (misplaced_pid == NPOS)
return false;
SIZE_TYPE pos = misplaced_pid + sizeof("; PID: ") - 1;
stat_info.SetInteger(pid_key, NStr::StringToInt8(
CTempString(executable_path.data() + pos,
executable_path.length() - pos)));
executable_path.erase(misplaced_pid);
return true;
}
inline
TSqlString x_MakeTSqlString(const CTempString& s, EEncoding enc)
{
#if defined(UNICODE) || defined(_UNICODE) || defined(UCS2)
return CUtf8::AsBasicString<TSqlChar>(CUtf8::AsUTF8(s, enc));
#else
if (enc == eEncoding_Unknown || enc == eEncoding_UTF8) {
return CUtf8::AsSingleByteString(CUtf8::AsUTF8(s, enc),
eEncoding_ISO8859_1);
} else {
return CSqlString(s.data(), s.size());
}
#endif
}
string CDBParamVariant::MakePlainName(const CTempString& name)
{
// Do not make copy of name to process it ...
CTempString plain_name;
CTempString::const_iterator begin_str = NULL, c = name.data();
for (; c != NULL && c != name.end(); ++c) {
char ch = *c;
if (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r') {
if (begin_str == NULL) {
// Remove whitespaces ...
continue;
} else {
// Look forward for non-space characters.
bool space_chars_only = true;
for (const char* tc = c; tc != NULL && *tc != '\0'; ++tc) {
char tch = *tc;
if (tch == ' ' || tch == '\t' || tch == '\n' || tch == '\r') {
continue;
} else {
space_chars_only = false;
break;
}
}
if (space_chars_only) {
// Remove trailing whitespace ...
break;
}
}
}
// Check for leading symbol ...
if (begin_str == NULL) {
begin_str = c;
if (ch == ':' || ch == '@' || ch == '$' || ch == '%') {
// Skip leading symbol ...
++begin_str;
}
}
}
if (begin_str != NULL) {
plain_name.assign(begin_str, c - begin_str);
}
return plain_name;
}
void CDelta_ext::AddAndSplit(const CTempString& src, CSeq_data::E_Choice in_format,
TSeqPos length /* in residues */,
bool gaps_ok, bool allow_packing)
{
CSeqUtil::TCoding coding = CSeqUtil::e_not_set;
switch (in_format) {
case CSeq_data::e_Iupacna: coding = CSeqUtil::e_Iupacna; break;
case CSeq_data::e_Iupacaa: coding = CSeqUtil::e_Iupacaa; break;
case CSeq_data::e_Ncbi4na: coding = CSeqUtil::e_Ncbi4na; break;
case CSeq_data::e_Ncbi8na: coding = CSeqUtil::e_Ncbi8na; break;
case CSeq_data::e_Ncbi8aa: coding = CSeqUtil::e_Ncbi8aa; break;
case CSeq_data::e_Ncbieaa: coding = CSeqUtil::e_Ncbieaa; break;
case CSeq_data::e_Ncbistdaa: coding = CSeqUtil::e_Ncbistdaa; break;
default:
coding = CSeqUtil::e_not_set;
}
if (allow_packing)
{
CDelta_ext_PackTarget dst(*this, gaps_ok);
CSeqConvert::Pack(src.data(), length, coding, dst);
}
else
{
// add as a single piece
CRef<CSeq_data> data (new CSeq_data(src, in_format));
CRef<CDelta_seq> ds (new CDelta_seq);
CSeq_literal& lit = ds->SetLiteral();
lit.SetLength(length);
lit.SetSeq_data(*data);
Set().push_back(ds);
}
}
CRef<CSeq_entry>
CShortReadFastaInputSource::x_ReadFastaOneSeq(CRef<ILineReader> line_reader)
{
int start = 0;
// parse the last read defline
CTempString line = **line_reader;
CTempString id = x_ParseDefline(line);
CRef<CSeq_id> seqid(new CSeq_id);
seqid->Set(CSeq_id::e_Local, id);
++(*line_reader);
line = **line_reader;
while (line[0] != '>') {
// ignore empty lines
if (line.empty() && !line_reader->AtEOF()) {
++(*line_reader);
line = **line_reader;
continue;
}
// copy the sequence
// increase the sequence buffer if necessary
if (start + line.length() + 1 > m_SeqBuffLen) {
string tmp;
m_SeqBuffLen = 2 * (start + line.length() + 1);
tmp.reserve(m_SeqBuffLen);
memcpy(&tmp[0], &m_Sequence[0], start);
m_Sequence.swap(tmp);
}
memcpy(&m_Sequence[start], line.data(), line.length());
start += line.length();
if (line_reader->AtEOF()) {
break;
}
// read next line
++(*line_reader);
line = **line_reader;
}
// set up sequence
if (start > 0) {
CRef<CSeq_entry> seq_entry(new CSeq_entry);
CBioseq& bioseq = seq_entry->SetSeq();
bioseq.SetInst().SetMol(CSeq_inst::eMol_na);
bioseq.SetInst().SetRepr(CSeq_inst::eRepr_raw);
bioseq.SetId().clear();
bioseq.SetId().push_back(seqid);
bioseq.SetInst().SetLength(start);
m_Sequence[start] = 0;
bioseq.SetInst().SetSeq_data().SetIupacna(CIUPACna(&m_Sequence[0]));
bioseq.SetDescr();
m_BasesAdded += start;
return seq_entry;
}
return CRef<CSeq_entry>();
}
CShortReadFastaInputSource::CShortReadFastaInputSource(CNcbiIstream& infile1,
CNcbiIstream& infile2,
CShortReadFastaInputSource::EInputFormat format)
: m_SeqBuffLen(550),
m_LineReader(new CStreamLineReader(infile1)),
m_SecondLineReader(new CStreamLineReader(infile2)),
m_IsPaired(true),
m_Format(format)
{
if (m_Format == eFastc) {
m_LineReader.Reset();
m_SecondLineReader.Reset();
NCBI_THROW(CInputException, eInvalidInput, "FASTC format cannot be "
"used with two input files");
}
// allocate sequence buffer
m_Sequence.reserve(m_SeqBuffLen + 1);
// read the first line for FASTA input
if (m_Format == eFasta) {
CTempString line;
do {
++(*m_LineReader);
line = **m_LineReader;
} while (line.empty() && !m_LineReader->AtEOF());
if (line[0] != '>') {
NCBI_THROW(CInputException, eInvalidInput, "FASTA parse error: "
"defline expected");
}
do {
++(*m_SecondLineReader);
line = **m_SecondLineReader;
} while (line.empty() && !m_SecondLineReader->AtEOF());
if (line[0] != '>') {
NCBI_THROW(CInputException, eInvalidInput, "FASTA parse error: "
"defline expected");
}
}
}
const char * CBlastDbBlob::x_ReadRaw(int size, int * offsetp) const
{
_ASSERT(offsetp);
_ASSERT(size >= 0);
CTempString s = Str();
int begin = *offsetp;
int end = begin + size;
if (begin > end || end > (int)s.size()) {
NCBI_THROW(CSeqDBException,
eFileErr,
"CBlastDbBlob::x_ReadRaw: hit end of data");
}
*offsetp = end;
return s.data() + begin;
}
void operator()( const CDirEntry & dirEntry ) {
if( ! dirEntry.IsFile() ) {
return;
}
CFile file(dirEntry);
string name = file.GetName();
if (NStr::EndsWith(name, ".txt") || NStr::StartsWith(name, ".")) {
return;
}
// extract info from the file name
const string sFileName = file.GetName();
vector<CTempString> vecFileNamePieces;
NStr::Split( sFileName, ".", vecFileNamePieces );
BOOST_REQUIRE(vecFileNamePieces.size() == 2);
CTempString tsTestName = vecFileNamePieces[0];
BOOST_REQUIRE(!tsTestName.empty());
CTempString tsFileType = vecFileNamePieces[1];
BOOST_REQUIRE(!tsFileType.empty());
STestInfo & test_info_to_load =
(*m_pTestNameToInfoMap)[vecFileNamePieces[0]];
// figure out what type of file we have and set appropriately
if (tsFileType == mExtInput) {
BOOST_REQUIRE( test_info_to_load.mInFile.GetPath().empty() );
test_info_to_load.mInFile = file;
}
else if (tsFileType == mExtOutput) {
BOOST_REQUIRE( test_info_to_load.mOutFile.GetPath().empty() );
test_info_to_load.mOutFile = file;
}
else if (tsFileType == mExtErrors) {
BOOST_REQUIRE( test_info_to_load.mErrorFile.GetPath().empty() );
test_info_to_load.mErrorFile = file;
}
else {
BOOST_FAIL("Unknown file type " << sFileName << ".");
}
}
///
/// This is the normative copy of the function
///
double ComputeNormalizedEntropy(const CTempString& sequence,
size_t word_size)
{
typedef map<CTempString, double> TCounts;
TCounts counts;
double total = sequence.size() - word_size;
for (size_t i = word_size; i < sequence.size(); ++i) {
CTempString t(sequence, i - word_size, word_size);
TCounts::iterator it =
counts.insert(TCounts::value_type(t, 0)).first;
it->second += 1;
}
NON_CONST_ITERATE (TCounts, it, counts) {
it->second /= total;
}
double entropy = 0;
ITERATE (TCounts, it, counts) {
entropy += it->second * log(it->second);
}
void CRequestContext::x_UpdateStdPassThroughProp(CTempString name) const
{
if (name.empty() || NStr::EqualNocase(name, kPassThrough_Sid)) {
if ( IsSetSessionID() ) {
x_SetPassThroughProp(kPassThrough_Sid, GetSessionID(), false);
}
else {
x_ResetPassThroughProp(kPassThrough_Sid, false);
}
}
if (name.empty() || NStr::EqualNocase(name, kPassThrough_ClientIp)) {
if ( IsSetClientIP() ) {
x_SetPassThroughProp(kPassThrough_ClientIp, GetClientIP(), false);
}
else {
x_ResetPassThroughProp(kPassThrough_ClientIp, false);
}
}
if (name.empty() || NStr::EqualNocase(name, kPassThrough_Dtab)) {
if ( IsSetDtab() ) {
x_SetPassThroughProp(kPassThrough_Dtab, GetDtab(), false);
}
else {
x_ResetPassThroughProp(kPassThrough_Dtab, false);
}
}
if (name.empty() || NStr::EqualNocase(name, kPassThrough_Phid)) {
if ( IsSetHitID() ) {
string sub_phid = const_cast<CRequestContext&>(*this).GetCurrentSubHitID();
if ( sub_phid.empty() ) {
sub_phid = const_cast<CRequestContext&>(*this).GetNextSubHitID();
}
x_SetPassThroughProp(kPassThrough_Phid, sub_phid, false);
}
else {
x_ResetPassThroughProp(kPassThrough_Phid, false);
}
}
}
CTempString CBlastDbBlob::x_ReadString(EStringFormat fmt, int * offsetp) const
{
int sz = 0;
if (fmt == eSize4) {
sz = x_ReadIntFixed<int,4>(offsetp);
} else if (fmt == eSizeVar) {
sz = x_ReadVarInt(offsetp);
}
const char * datap = "";
if (fmt == eNUL) {
CTempString ts = Str();
int zoffset = -1;
for(size_t i = *offsetp; i < ts.size(); i++) {
if (ts[i] == (char)0) {
zoffset = i;
break;
}
}
if (zoffset == -1) {
NCBI_THROW(CSeqDBException,
eFileErr,
"CBlastDbBlob::ReadString: Unterminated string.");
}
datap = ts.data() + *offsetp;
sz = zoffset - *offsetp;
*offsetp = zoffset+1;
} else {
datap = x_ReadRaw(sz, offsetp);
}
return CTempString(datap, sz);
}
static void s_ProcessECNumberLine(const CTempString& line,
CProt_ref::EECNumberStatus status)
{
if (status == CProt_ref::eEC_replaced) {
SIZE_TYPE tab_pos = line.find('\t');
if (tab_pos == NPOS) {
ERR_POST_X(1, Warning << "No tab in ecnum_replaced entry " << line
<< "; disregarding");
} else {
string lhs(line.substr(0, tab_pos)), rhs(line.substr(tab_pos + 1));
s_ECNumberStatusMap[lhs] = status;
s_ECNumberReplacementMap[lhs] = rhs;
}
} else {
SIZE_TYPE tab_pos = line.find('\t');
if (tab_pos == NPOS) {
s_ECNumberStatusMap[line] = status;
} else {
string lhs(line.substr(0, tab_pos));
s_ECNumberStatusMap[lhs] = status;
}
}
}
BEGIN_NCBI_SCOPE
static void NormalizeStatKeyName(CTempString& key)
{
char* begin = const_cast<char*>(key.data());
char* end = begin + key.length();
while (begin < end && !isalnum(*begin))
++begin;
while (begin < end && !isalnum(end[-1]))
--end;
if (begin == end) {
key = "_";
return;
}
key.assign(begin, end - begin);
for (; begin < end; ++begin)
*begin = isalnum(*begin) ? tolower(*begin) : '_';
}
Int8 CBlastDbBlob::x_ReadVarInt(int * offsetp) const
{
CTempString all = Str();
Int8 rv(0);
for(size_t i = *offsetp; i < all.size(); i++) {
int ch = all[i];
if (ch & 0x80) {
// middle
rv = (rv << 7) | (ch & 0x7F);
} else {
// end
rv = (rv << 6) | (ch & 0x3F);
*offsetp = i+1;
return (ch & 0x40) ? -rv : rv;
}
}
NCBI_THROW(CSeqDBException,
eFileErr,
"CBlastDbBlob::ReadVarInt: eof while reading integer.");
}
TMemberIndex CObjectIStreamJson::FindDeep(
const CItemsInfo& items, const CTempString& name, bool& deep) const
{
TMemberIndex i = items.Find(name);
if (i != kInvalidMember) {
deep = false;
return i;
}
i = items.FindDeep(name);
if (i != kInvalidMember) {
deep = true;
return i;
}
// on writing, we replace hyphens with underscores;
// on reading, it complicates our life
if (name.find_first_of("_") != CTempString::npos) {
TMemberIndex first = items.FirstIndex();
TMemberIndex last = items.LastIndex();
for (i = first; i <= last; ++i) {
const CItemInfo *itemInfo = items.GetItemInfo(i);
string item_name = itemInfo->GetId().GetName();
NStr::ReplaceInPlace(item_name,"-","_");
if (name == item_name) {
deep = false;
return i;
}
}
for (i = first; i <= last; ++i) {
const CItemInfo* itemInfo = items.GetItemInfo(i);
const CMemberId& id = itemInfo->GetId();
if (!id.IsAttlist() && id.HasNotag()) {
const CClassTypeInfoBase* classType =
dynamic_cast<const CClassTypeInfoBase*>(
CItemsInfo::FindRealTypeInfo(itemInfo->GetTypeInfo()));
if (classType) {
if (FindDeep(classType->GetItems(), name, deep) != kInvalidMember) {
deep = true;
return i;
}
}
}
}
}
deep = true;
return kInvalidMember;
}
TMemberIndex CObjectIStreamAsn::GetChoiceIndex
(const CChoiceTypeInfo* choiceType,
const CTempString& id)
{
TMemberIndex idx;
if (!id.empty() && isdigit((unsigned char) id[0])) {
idx = choiceType->GetVariants().Find
(CMemberId::TTag(NStr::StringToInt(id)), CAsnBinaryDefs::eContextSpecific);
}
else {
idx = choiceType->GetVariants().Find(id);
if (idx == kInvalidMember) {
idx = GetAltItemIndex(choiceType,id);
}
}
return idx;
}
// ----------------------------------------------------------------------------
void CUCSCRegionReader::xSmartFieldSplit(vector<string>& fields, CTempString line)
{
NStr::Split(line, " \t.-:", fields, NStr::fSplit_Tokenize);
if (line[line.length()-1] == '-')
fields.push_back("-");
while (fields.size() > 3)
{
if (fields.size() == 4 && (fields.back() == "+" || fields.back() == "-"))
break;
// try to merge first column
size_t len = fields[0].length();
if (line[len] == '.')
{
fields[0] += line[len];
fields[0] += fields[1];
fields.erase(fields.begin()+1);
} else {
break;
}
}
}
TMemberIndex CObjectIStreamAsn::GetAltItemIndex(
const CClassTypeInfoBase* classType,
const CTempString& id,
const TMemberIndex pos /*= kInvalidMember*/)
{
TMemberIndex idx = kInvalidMember;
if (!id.empty()) {
const CItemsInfo& info = classType->GetItems();
string id_alt = string(id);
id_alt[0] = toupper((unsigned char)id_alt[0]);
if (pos != kInvalidMember) {
idx = info.Find(CTempString(id_alt),pos);
} else {
idx = info.Find(CTempString(id_alt));
}
if (idx != kInvalidMember &&
!info.GetItemInfo(idx)->GetId().HaveNoPrefix()) {
idx = kInvalidMember;
}
}
return idx;
}
CRef<CSeq_entry>
CShortReadFastaInputSource::x_ReadFastqOneSeq(CRef<ILineReader> line_reader)
{
CTempString line;
CTempString id;
CRef<CSeq_entry> retval;
// first read defline
++(*line_reader);
line = **line_reader;
// skip empty lines
while (!line_reader->AtEOF() && line.empty()) {
++(*line_reader);
line = **line_reader;
}
if (line[0] != '@') {
NCBI_THROW(CInputException, eInvalidInput, (string)"FASTQ parse error:"
" defline expected at line: " +
NStr::IntToString(line_reader->GetLineNumber()));
}
id = x_ParseDefline(line);
CRef<CSeq_id> seqid(new CSeq_id);
seqid->Set(CSeq_id::e_Local, id);
// read sequence
++(*line_reader);
line = **line_reader;
// skip empty lines
while (!line_reader->AtEOF() && line.empty()) {
++(*line_reader);
line = **line_reader;
}
// set up sequence
if (line.length() > 0) {
CRef<CSeq_entry> seq_entry(new CSeq_entry);
CBioseq& bioseq = seq_entry->SetSeq();
bioseq.SetInst().SetMol(CSeq_inst::eMol_na);
bioseq.SetInst().SetRepr(CSeq_inst::eRepr_raw);
bioseq.SetId().clear();
bioseq.SetId().push_back(seqid);
bioseq.SetInst().SetLength(line.length());
bioseq.SetInst().SetSeq_data().SetIupacna(CIUPACna(line.data()));
bioseq.SetDescr();
m_BasesAdded += line.length();
retval = seq_entry;
}
// read and skip second defline
++(*line_reader);
line = **line_reader;
// skip empty lines
while (!line_reader->AtEOF() && line.empty()) {
++(*line_reader);
line = **line_reader;
}
if (line[0] != '+') {
NCBI_THROW(CInputException, eInvalidInput, (string)"FASTQ parse error:"
" defline expected at line: " +
NStr::IntToString(line_reader->GetLineNumber()));
}
// read and skip quality scores
++(*line_reader);
line = **line_reader;
// skip empty lines
while (!line_reader->AtEOF() && line.empty()) {
++(*line_reader);
line = **line_reader;
}
return retval;
}
void Reset(const CTempString& line)
{
const char* line_buf = line.data();
Reset(line_buf, line_buf + line.size());
}
inline
CLightString::CLightString(const CTempString& str)
: m_String(str.data()), m_Length(str.length())
{
}
BEGIN_NCBI_SCOPE
//////////////////////////////////////////////////////////////////////////////
static
TSvrRef
make_server(const CTempString& specification, double& preference)
{
CTempString server;
// string host;
Uint4 host = 0;
Uint2 port = 0;
string::size_type pos = 0;
pos = specification.find_first_of("@(", pos);
if (pos != string::npos) {
server = specification.substr(0, pos);
if (specification[pos] == '@') {
// string::size_type old_pos = pos + 1;
pos = specification.find_first_of(":(", pos + 1);
if (pos != string::npos) {
// string host_str = specification.substr(old_pos, pos - old_pos);
// Ignore host in order to avoid dependebcy on libconnect.
// SOCK_StringToHostPort(specification.c_str() + old_pos, &host, &port);
if (specification[pos] == ':') {
port = NStr::StringToUInt(specification.substr(pos + 1),
NStr::fAllowLeadingSpaces |
NStr::fAllowTrailingSymbols |
NStr::fConvErr_NoThrow);
pos = specification.find("(", pos + 1);
if (pos != string::npos) {
// preference = NStr::StringToDouble(
preference = NStr::StringToUInt(
specification.substr(pos + 1),
NStr::fAllowLeadingSpaces |
NStr::fAllowTrailingSymbols |
NStr::fConvErr_NoThrow);
}
} else {
// preference = NStr::StringToDouble(
preference = NStr::StringToUInt(
specification.substr(pos + 1),
NStr::fAllowLeadingSpaces |
NStr::fAllowTrailingSymbols |
NStr::fConvErr_NoThrow);
}
} else {
// host = specification.substr(old_pos);
// Ignore host in order to avoid dependebcy on libconnect.
// SOCK_StringToHostPort(specification.c_str() + old_pos, &host, &port);
}
} else {
// preference = NStr::StringToDouble(
preference = NStr::StringToUInt(
specification.substr(pos + 1),
NStr::fAllowLeadingSpaces |
NStr::fAllowTrailingSymbols |
NStr::fConvErr_NoThrow);
}
} else {
server = specification;
}
if (server.empty() && host == 0) {
DATABASE_DRIVER_ERROR("Either server name or host name expected.",
110100 );
}
return TSvrRef(new CDBServer(server, host, port));
}