qlInterpolatedYieldCurve::qlInterpolatedYieldCurve(
const std::string& ObjectId,
const ObjectHandler::property_t& RefDate,
const std::vector<ObjectHandler::property_t>& Dates,
const std::vector<double>& Data,
const std::string& Calendar,
const std::string& DayCounter,
const std::vector<ObjectHandler::property_t>& Jumps,
const std::vector<ObjectHandler::property_t>& JumpDates,
const std::string& TraitsID,
const std::string& InterpolatorID,
bool Permanent) :
ObjectHandler::ValueObject(ObjectId, "qlInterpolatedYieldCurve", Permanent),
RefDate_(RefDate),
Dates_(Dates),
Data_(Data),
Calendar_(Calendar),
DayCounter_(DayCounter),
Jumps_(Jumps),
JumpDates_(JumpDates),
TraitsID_(TraitsID),
InterpolatorID_(InterpolatorID),
Permanent_(Permanent) {
processVariant(Jumps);
}
qlForwardSpreadedTermStructure::qlForwardSpreadedTermStructure(
const std::string& ObjectId,
const std::string& BaseYieldCurve,
const ObjectHandler::property_t& Spread,
bool Permanent) :
ObjectHandler::ValueObject(ObjectId, "qlForwardSpreadedTermStructure", Permanent),
BaseYieldCurve_(BaseYieldCurve),
Spread_(Spread),
Permanent_(Permanent) {
processPrecedentID(BaseYieldCurve);
processVariant(Spread);
}
void PacketDecodeNode::processVariant( QVariant V )
{
if( V.type() == QVariant::List )
{
QVariantList L = V.toList();
for( QVariant I : L )
{
processVariant( I );
}
}
else if( V.canConvert( QVariant::ByteArray ) )
{
processByteArray( V.toByteArray() );
}
}
qlFlatHazardRate::qlFlatHazardRate(
const std::string& ObjectId,
long NDays,
const std::string& Calendar,
const ObjectHandler::property_t& Rate,
const std::string& DayCounter,
bool Permanent) :
ObjectHandler::ValueObject(ObjectId, "qlFlatHazardRate", Permanent),
NDays_(NDays),
Calendar_(Calendar),
Rate_(Rate),
DayCounter_(DayCounter),
Permanent_(Permanent) {
processVariant(Rate);
}
void PacketDecodeNode::inputsUpdated( qint64 pTimeStamp )
{
NodeControlBase::inputsUpdated( pTimeStamp );
mValOutputData->variantClear();
fugio::PinVariantIterator Packets( mPinInputPackets );
for( int i = 0 ; i < Packets.count() ; i++ )
{
processVariant( Packets.index( i ) );
}
if( mValOutputData->variantCount() )
{
pinUpdated( mPinOutputData );
}
}
qlSabrVolSurface::qlSabrVolSurface(
const std::string& ObjectId,
const std::string& InterestRateIndex,
const std::string& BlackAtmVolCurve,
const std::vector<ObjectHandler::property_t>& OptionTenors,
const std::vector<double>& AtmRateSpreads,
const std::vector<std::vector<ObjectHandler::property_t> >& VolatilitiesQuotes,
bool Permanent) :
ObjectHandler::ValueObject(ObjectId, "qlSabrVolSurface", Permanent),
InterestRateIndex_(InterestRateIndex),
BlackAtmVolCurve_(BlackAtmVolCurve),
OptionTenors_(OptionTenors),
AtmRateSpreads_(AtmRateSpreads),
VolatilitiesQuotes_(VolatilitiesQuotes),
Permanent_(Permanent) {
processPrecedentID(InterestRateIndex);
processPrecedentID(BlackAtmVolCurve);
processVariant(VolatilitiesQuotes);
}
qlFlatForward::qlFlatForward(
const std::string& ObjectId,
long NDays,
const std::string& Calendar,
const ObjectHandler::property_t& Rate,
const std::string& DayCounter,
const std::string& Compounding,
const std::string& Frequency,
bool Permanent) :
ObjectHandler::ValueObject(ObjectId, "qlFlatForward", Permanent),
NDays_(NDays),
Calendar_(Calendar),
Rate_(Rate),
DayCounter_(DayCounter),
Compounding_(Compounding),
Frequency_(Frequency),
Permanent_(Permanent) {
processVariant(Rate);
}
void PacketEncodeNode::inputsUpdated( qint64 pTimeStamp )
{
NodeControlBase::inputsUpdated( pTimeStamp );
if( mPinInputData->isUpdated( pTimeStamp ) )
{
mValOutputPacket->variantClear();
fugio::PinVariantIterator Data( mPinInputData );
for( int i = 0 ; i < Data.count() ; i++ )
{
processVariant( Data.index( i ) );
}
if( mValOutputPacket->variantCount() )
{
pinUpdated( mPinOutputPacket );
}
}
}
qlAbcdAtmVolCurve::qlAbcdAtmVolCurve(
const std::string& ObjectId,
long SettlementDays,
const std::string& Calendar,
const std::vector<ObjectHandler::property_t>& OptionTenors,
const std::vector<ObjectHandler::property_t>& VolatilitiesQuotes,
const std::vector<bool>& InclusionInInterpolation,
const std::string& Convention,
const std::string& DayCounter,
bool Permanent) :
ObjectHandler::ValueObject(ObjectId, "qlAbcdAtmVolCurve", Permanent),
SettlementDays_(SettlementDays),
Calendar_(Calendar),
OptionTenors_(OptionTenors),
VolatilitiesQuotes_(VolatilitiesQuotes),
InclusionInInterpolation_(InclusionInInterpolation),
Convention_(Convention),
DayCounter_(DayCounter),
Permanent_(Permanent) {
processVariant(VolatilitiesQuotes);
}
int main(int argc, char *argv[])
{
struct sqlConnection *conn2, *conn3;
char query2[256], query3[256];
struct sqlResult *sr2, *sr3;
char **row2, **row3;
char *proteinDb;
char *database;
char *acc, *start, *end;
char *accession;
char *displayID;
char *division;
char *extDB;
char *extAC;
char *proteinDataDate;
char *genomeRelease;
int i;
char *swissID, *pdb;
char *name, *chrom, *strand, *txStart, *txEnd, *cdsStart, *cdsEnd,
*exonCount, *exonStarts, *exonEnds;
int iStart;
char *varId;
char *aaSeq;
char *lenStr;
int varLen;
char *orig;
int aaSeqLen;
char *outFileName;
char baseAa, variantAa;
char *origSeq;
char *varSeq;
FILE *outf;
if (argc != 4) usage();
proteinDb = argv[1];
database = argv[2];
outFileName = argv[3];
hSetDb(database);
outf = mustOpen(outFileName, "w");
conn2 = sqlConnect(proteinDb);
conn3 = sqlConnect(proteinDb);
sprintf(query2,"select * from %s.dv", database);
sr2 = sqlMustGetResult(conn2, query2);
row2 = sqlNextRow(sr2);
while (row2 != NULL)
{
acc = row2[0];
start = row2[1];
lenStr = row2[2];
origSeq = row2[3];
varSeq = row2[4];
varId = row2[5];
iStart = atoi(start);
varLen = atoi(lenStr);
/* get protein sequence */
sprintf(query3, "select val from %s.protein where acc='%s'", proteinDb, acc);
sr3 = sqlMustGetResult(conn3, query3);
row3 = sqlNextRow(sr3);
aaSeq = row3[0];
aaSeqLen = strlen(aaSeq);
if (strlen(varSeq) >= 255)
{
fprintf(stderr,"varSeq longer than 255 AA: \t%s\t%s\n", varSeq, varId);
*(varSeq+255) = '\0';
}
processVariant(database, acc, aaSeqLen, iStart, varLen, origSeq, varSeq, varId, outf);
sqlFreeResult(&sr3);
row2 = sqlNextRow(sr2);
}
sqlFreeResult(&sr2);
fclose(outf);
fflush(stdout);
printf("np=%d np0=%d np1=%d not covered = %d\n", np, np0, np1, np - np0 - np1);fflush(stdout);
printf("nn=%d nn0=%d nn1=%d not covered = %d\n", nn, nn0, nn1, nn - nn0 - nn1);fflush(stdout);
return(0);
}
