void WMAPSource::addToMetadata( fitsfile *ffits, int &iStatus )
{
QString str;
int iResult;
int keysexist;
int morekeys;
iResult = fits_get_hdrspace( ffits, &keysexist, &morekeys, &iStatus );
if( iResult == 0 )
{
QString strTable;
KstObjectTag tableTag( strTable, tag( ) );
char keyname[FLEN_KEYWORD];
char value[FLEN_VALUE];
char comment[FLEN_COMMENT];
int keynum;
for( keynum=1; keynum<=keysexist; ++keynum )
{
iResult = fits_read_keyn( ffits, keynum, keyname, value, comment, &iStatus );
if( iResult == 0 )
{
KstString *metaString;
KstObjectTag newTag( keyname, tag( ) );
str.sprintf( "%s %s", value, comment );
metaString = new KstString( newTag, this, str );
_metaData.insert( keyname, metaString );
}
}
}
}
bool MetaBundle::XmlLoader::characters( const QString &ch )
{
if( m_currentElement.isNull() )
return true;
newTag( m_currentElement, ch );
return true;
}
void KstPSD::setTagName(const QString &in_tag) {
KstObjectTag newTag(in_tag, tag().context());
if (newTag == tag()) {
return;
}
KstObject::setTagName(newTag);
(*_sVector)->setTagName(KstObjectTag("sv", tag()));
(*_fVector)->setTagName(KstObjectTag("freq", tag()));
}
void WMAPSource::addToMetadata( fitsfile *ffits, const int iNumCols, int &iStatus )
{
QString str;
char charTemplate[ FLEN_CARD ];
char charName[ FLEN_CARD ];
long lRepeat;
long lWidth;
int iTypeCode;
int iColNumber;
int iResult;
int entry;
int col;
for( col=0; col<iNumCols; col++ )
{
iResult = fits_get_coltype( ffits, col+1, &iTypeCode, &lRepeat, &lWidth, &iStatus );
if( iResult == 0 )
{
sprintf( charTemplate, "%d", col+1 );
iResult = fits_get_colname( ffits, CASEINSEN, charTemplate, charName, &iColNumber, &iStatus );
if( iResult == 0 )
{
if( lRepeat == 3 )
{
QString strValue;
double dNan = strtod( "nan", NULL );
double value;
int iAnyNull;
for( entry=0; entry<lRepeat; entry++ )
{
iResult = fits_read_col( ffits, TDOUBLE, iColNumber, 1, entry+1, 1, &dNan, &value, &iAnyNull, &iStatus );
if( iResult == 0 )
{
KstString *metaString;
QString keyname = QString("%1_%2").arg(charName).arg(QChar('X'+entry));
KstObjectTag newTag( keyname, tag( ) );
strValue = QString("%1").arg(value);
metaString = new KstString( newTag, this, strValue );
_metaData.insert( keyname, metaString );
}
}
}
}
}
}
}
void KstCPlugin::setTagName(const QString &in_tag) {
KstObjectTag newTag(in_tag, tag().context());
if (newTag == tag()) {
return;
}
KstObject::setTagName(newTag);
for (KstVectorMap::Iterator iter = outputVectors().begin(); iter != outputVectors().end(); ++iter) {
(*iter)->setTagName(KstObjectTag(iter.data()->tag().tag(), tag()));
}
for (KstScalarMap::Iterator iter = outputScalars().begin(); iter != outputScalars().end(); ++iter) {
(*iter)->setTagName(KstObjectTag(iter.data()->tag().tag(), tag()));
}
for (KstStringMap::Iterator iter = outputStrings().begin(); iter != outputStrings().end(); ++iter) {
(*iter)->setTagName(KstObjectTag(iter.data()->tag().tag(), tag()));
}
}
void NewTag::OnOK()
{
if (m_nId == 0) {
// calculate new id
m_nId = RS_MSGTAGTYPE_USER;
std::map<uint32_t, std::pair<std::string, uint32_t> >::iterator Tag;
for (Tag = m_Tags.types.begin(); Tag != m_Tags.types.end(); Tag++) {
if (Tag->first + 1 > m_nId) {
m_nId = Tag->first + 1;
}
}
}
std::pair<std::string, uint32_t> newTag(ui.lineEdit->text().toStdString(), m_Color);
m_Tags.types [m_nId] = newTag;
setResult(QDialog::Accepted);
hide();
}
void Imap4Analyser::analyse(const char* content, size_t length, const SessionId& sessionId)
{
LOG4CPLUS_TRACE(LOGGER, "********************analyse enter, content=" << content << ", length=" << length << ", sessionId=" << sessionId);
// 长度至少要为最小可分析长度
if (0 == content || MIN_LENGTH > length) {
LOG4CPLUS_WARN(LOGGER, "invalid packet, content error or length error");
LOG4CPLUS_TRACE(LOGGER, "analyse leave");
return;
}
string str(content);
// 查找第一个空格，将之前的内容视为标签
size_t tagEndPos = str.find_first_of(' ');
// 未找到空格，视为无效数据
if (string::npos == tagEndPos) {
LOG4CPLUS_WARN(LOGGER, "invalid packet, can't find blank character");
LOG4CPLUS_TRACE(LOGGER, "analyse leave");
return;
}
// 标签长度为零
if (0 == tagEndPos) {
LOG4CPLUS_WARN(LOGGER, "invalid packet, tag length is zero");
LOG4CPLUS_TRACE(LOGGER, "analyse leave");
return;
}
// 得到标签
string tag = str.substr(0, tagEndPos);
LOG4CPLUS_TRACE(LOGGER, "get tag, tag=" << tag);
// 测试长度是否足够继续分析
if (tagEndPos + 1 >= length) {
LOG4CPLUS_WARN(LOGGER, "invalid packet, content deficient");
LOG4CPLUS_TRACE(LOGGER, "analyse leave");
return;
}
// 查找LOGIN命令
size_t cmdOrResponseBeginPos = str.find(COMMAND_LOGIN, tagEndPos + 1);
// 找到LOGIN命令
if (string::npos != cmdOrResponseBeginPos && tagEndPos + 1 == cmdOrResponseBeginPos) {
LOG4CPLUS_TRACE(LOGGER, "get LOGIN cmd");
// 测试长度是否足够继续分析
size_t cmdEndPos = cmdOrResponseBeginPos + COMMAND_LOGIN.size();
if (cmdOrResponseBeginPos + 2 >= length) {
LOG4CPLUS_WARN(LOGGER, "invalid packet, content deficient");
LOG4CPLUS_TRACE(LOGGER, "analyse leave");
return;
}
// 查找登录用户名
size_t userNameEndPos = str.find_first_of(' ', cmdEndPos + 2);
if (string::npos == userNameEndPos) {
LOG4CPLUS_WARN(LOGGER, "invalid login cmd, can't find user name");
LOG4CPLUS_TRACE(LOGGER, "analyse leave");
return;
}
// 获取登录用户名
string userName = str.substr(cmdEndPos, userNameEndPos - cmdEndPos);
LOG4CPLUS_TRACE(LOGGER, "get LOGIN user name, userName="******"removed existing sessionInfo");
}
// 创建新的会话信息
SessionInfo * const sessionInfoP = new SessionInfo();
putSessionInfo(sessionId, *sessionInfoP);
// 放入登录信息
CmdInfo* cmdInfoP = new CmdInfo();
cmdInfoP->setCmdId(ID_COMMAND_LOGIN);
const time_t now = time(0);
cmdInfoP->setStartMillis(now * 1000);
// 放入命令标签
int key = PROPS_KEY_TAG;
pair<int, void*> propTag(key, new string(tag));
cmdInfoP->addProperty(propTag);
// 放入用户名
key = PROPS_KEY_USER_NAME;
pair<int, void*> propUserName(key, new string(userName));
cmdInfoP->addProperty(propUserName);
sessionInfoP->addCmd(cmdInfoP);
// 设置服务端和客户端IP
sessionInfoP->setServerIp(sessionId.getDestIp());
sessionInfoP->setServerPort(sessionId.getDestPort());
sessionInfoP->setClientIp(sessionId.getSourceIp());
sessionInfoP->setClientPort(sessionId.getSourcePort());
// 计算包数量和大小
sessionInfoP->setPacketsCount(1);
sessionInfoP->setBytesCount(54 + length);
LOG4CPLUS_TRACE(LOGGER, "analyse leave");
return;
}
LOG4CPLUS_TRACE(LOGGER, "can't find LOGIN cmd");
// 查看是否已经有相关信息，是否已经LOGIN
bool contained = containsSessionInfo(sessionId);
// 当前包是否为响应命令
bool isResponse = !contained;
const SessionId* reverseIdP = 0;
// 测试是否为响应包
if (!contained) {
reverseIdP = new SessionId(sessionId.getDestIp(), sessionId.getDestPort(), sessionId.getSourceIp(), sessionId.getSourcePort(), sessionId.getProtocolId());
contained = containsSessionInfo(*reverseIdP);
isResponse = contained;
}
// 非已知的会话包，丢弃
if (!contained) {
LOG4CPLUS_WARN(LOGGER, "ignored packed, can't find sessionInfo");
LOG4CPLUS_TRACE(LOGGER, "analyse leave");
return;
}
// 是已知的会话包，计算大小及包数
SessionInfo * const sessionInfoP = getSessionInfo(isResponse ? *reverseIdP : sessionId);
sessionInfoP->setPacketsCount((sessionInfoP->getPacketsCount() + 1));
sessionInfoP->setBytesCount(sessionInfoP->getBytesCount() + 54 + length);
// 非响应包，由客户端发向服务器
if (!isResponse) {
// 查找LOGINOUT命令
cmdOrResponseBeginPos = str.find(COMMAND_LOGOUT, tagEndPos + 1);
// 找到登出命令
if (string::npos != cmdOrResponseBeginPos && tagEndPos + 1 == cmdOrResponseBeginPos) {
LOG4CPLUS_TRACE(LOGGER, "get LOGOUT cmd");
// 放入登出信息
CmdInfo* cmdInfoP = new CmdInfo();
cmdInfoP->setCmdId(ID_COMMAND_LOGOUT);
const time_t now = time(0);
cmdInfoP->setStartMillis(now * 1000);
// 放入命令标签
int key = PROPS_KEY_TAG;
pair<int, void*> propTag(key, new string(tag));
cmdInfoP->addProperty(propTag);
sessionInfoP->addCmd(cmdInfoP);
}
LOG4CPLUS_TRACE(LOGGER, "analyse leave");
}
// 响应包，由服务器发向客户端
else {
// 先查找LOGIN的返回状态，先查看标签是否一致
vector<CmdInfo*> cmds = (*(sessionInfoP->getCmds()));
string* tagP = static_cast<string*> (cmds[0]->getProperty(PROPS_KEY_TAG));
bool isSameTag = *tagP == tag;
// 标签一致，是期待的LOGIN的响应
if (isSameTag) {
// 查找登录的命令响应
const size_t responseBeginPos = tagEndPos + 1;
int statusId = ID_RESPONSE_LOGIN_UNKNOW;
// 尝试OK响应
cmdOrResponseBeginPos = str.find(RESPONSE_LOGIN_OK, responseBeginPos);
if (string::npos != cmdOrResponseBeginPos && cmdOrResponseBeginPos == responseBeginPos) {
statusId = ID_RESPONSE_LOGIN_OK;
}
else {
// 尝试NO响应
cmdOrResponseBeginPos = str.find(RESPONSE_LOGIN_NO, responseBeginPos);
if (string::npos != cmdOrResponseBeginPos && cmdOrResponseBeginPos == responseBeginPos) {
statusId = ID_RESPONSE_LOGIN_NO;
}
else {
// 尝试BAD响应
cmdOrResponseBeginPos = str.find(RESPONSE_LOGIN_BAD, responseBeginPos);
if (string::npos != cmdOrResponseBeginPos && cmdOrResponseBeginPos == responseBeginPos) {
statusId = ID_RESPONSE_LOGIN_BAD;
}
}
}
const time_t now = time(0);
cmds[0]->setResponseMillis(now * 1000);
cmds[0]->setStatusId(statusId);
LOG4CPLUS_TRACE(LOGGER, "got LOGIN cmd response, statusId=" << statusId);
}
// 查找 LOGOUT 命令的响应
else {
// 是否已经收到LOGOUT命令
if (2 == cmds.size()) {
tagP = static_cast<string*> (cmds[1]->getProperty(PROPS_KEY_TAG));
// 查看标签是否一致
isSameTag = *tagP == tag;
size_t responseBeginPos = tagEndPos + 1;
if (!isSameTag && GENERAL_TAG == tag && responseBeginPos < length) {
string newTag("\r\n");
newTag.append(*tagP);
newTag.append(" ");
newTag.append(RESPONSE_LOGOUT_OK);
size_t tmp = str.find(newTag, responseBeginPos);
isSameTag = string::npos != tmp;
if (isSameTag) {
responseBeginPos = tmp + 3 + tagP->size();
}
// 再尝试BAD
if (!isSameTag) {
string newTag("\r\n");
newTag.append(*tagP);
newTag.append(" ");
newTag.append(RESPONSE_LOGOUT_BAD);
size_t tmp = str.find(newTag, responseBeginPos);
isSameTag = string::npos != tmp;
if (isSameTag) {
responseBeginPos = tmp + 3 + tagP->size();
}
}
}
// 标签一致，是期待的LOGOUT的响应
if (isSameTag) {
// 查找的登出命令响应
int statusId = ID_RESPONSE_LOGOUT_BAD;
// 尝试OK响应
cmdOrResponseBeginPos = str.find(RESPONSE_LOGOUT_OK, responseBeginPos);
if (string::npos != cmdOrResponseBeginPos && responseBeginPos == cmdOrResponseBeginPos) {
statusId = ID_RESPONSE_LOGOUT_OK;
}
const time_t now = time(0);
cmds[1]->setResponseMillis(now * 1000);
cmds[1]->setStatusId(statusId);
LOG4CPLUS_TRACE(LOGGER, "got LOGOUT cmd response, statusId=" << statusId);
log(sessionInfoP);
removeSessionInfo(*reverseIdP);
}
}
}
delete reverseIdP;
LOG4CPLUS_TRACE(LOGGER, "analyse leave");
}
}
Fenetre::Fenetre(QWidget *parent) : courant(0), QMainWindow(parent)
{
//*************************
courant = NULL;
folder = NULL;
resize(1200, 512);
//*************************** Menu ***************************
QMenu* mFile = menuBar()->addMenu("&File");
QMenu* mEdit = menuBar()->addMenu("&Edit");
QMenu* mView = menuBar()->addMenu("&View");
QMenu* mNouveau = mFile->addMenu("New");
QAction* mactionAnnuler = mEdit->addAction("Annuler");
QAction* mactionRefaire = mEdit->addAction("Refaire");
QAction* mactionSupprimer = mEdit->addAction("Supprimer");
QMenu* mTag = mEdit->addMenu("Tags");
QAction* mactionSupprimerTag = mTag->addAction("Supprimer");
QMenu* mDocument = mEdit->addMenu("Documents");
QAction* mactionUp = mDocument->addAction("Monter");
QAction* mactionDown = mDocument->addAction("Descendre");
QMenu* mExport = mEdit->addMenu("Exporter");
QAction* mactionOuvrir = mFile->addAction("Ouvrir un espace de travail");
QAction* mactionNew = mFile->addAction("Nouvel espace de travail");
QAction* mactionSaveAs = mFile->addAction("Enregistrer sous...");
QAction* mactionNewArticle = mNouveau->addAction("Article");
QAction* mactionNewImage = mNouveau->addAction("Image");
QAction* mactionNewAudio = mNouveau->addAction("Audio");
QAction* mactionNewVideo = mNouveau->addAction("Video");
QAction* mactionNewDocument = mNouveau->addAction("Document");
QAction* mactionExportHTML = mExport->addAction("Html");
QAction* mactionExportTex = mExport->addAction("Tex");
QAction* mactionExportTexte = mExport->addAction("Texte");
QAction* mactionOption=mEdit->addAction("Setting");
QAction* mactionAddTag = mNouveau->addAction("Tag");
QAction* mactionSave = mFile->addAction("Sauvegarder");
mFile->addSeparator();
QMenu* ouvrirCorbeille = mFile->addMenu("Corbeille");
QAction* mactionRestaurer = ouvrirCorbeille->addAction("Restaurer");
QAction* mactionVider = ouvrirCorbeille->addAction("Vider la Corbeille");
mactionViewEdit = mView->addAction("Onglet Editeur");
mactionViewHTML = mView->addAction("Onglet Html");
mactionViewTex = mView->addAction("Onglet Tex");
mactionViewTexte = mView->addAction("Onglet Texte");
mFile->addSeparator();
QAction* actionQuitter = mFile->addAction("&Quitter");
actionQuitter->setIcon(QIcon("icon/quitter.png"));
mactionNewArticle->setIcon(QIcon("icon/article.png"));
mactionNewImage->setIcon(QIcon("icon/image.png"));
mactionNewAudio->setIcon(QIcon("icon/audio.png"));
mactionNewVideo->setIcon(QIcon("icon/video.png"));
mNouveau->setIcon(QIcon("icon/plus.png"));
mactionDown->setIcon(QIcon("icon/down.png"));
mactionUp->setIcon(QIcon("icon/up.png"));
mactionAddTag->setIcon(QIcon("icon/tag.png"));
mactionSave->setIcon(QIcon("icon/save.png"));
mactionExportHTML->setIcon(QIcon("icon/html.png"));
mactionExportTex->setIcon(QIcon("icon/tex.png"));
mactionExportTexte->setIcon(QIcon("icon/texte.png"));
mactionAnnuler->setIcon(QIcon("icon/undo.png"));
mactionRefaire->setIcon(QIcon("icon/redo.png"));
mactionSupprimer->setIcon(QIcon("icon/cross.png"));
mactionRestaurer->setIcon(QIcon("icon/corbeille.png"));
mactionNewDocument->setIcon(QIcon("icon/document.png"));
mactionOption->setIcon(QIcon("icon/setting.png"));
mactionOuvrir->setShortcut(QKeySequence("Ctrl+O"));
actionQuitter->setShortcut(QKeySequence("Ctrl+Q"));
mactionSave->setShortcut(QKeySequence("Ctrl+S"));
mactionAnnuler->setShortcut(QKeySequence("Ctrl+Z"));
mactionRefaire->setShortcut(QKeySequence("Ctrl+Y"));
mactionSupprimer->setShortcut(tr("Delete"));
//** VIEW **//
mactionViewEdit->setCheckable(true);
mactionViewEdit->setChecked(true);
mactionViewHTML->setCheckable(true);
mactionViewTex->setCheckable(true);
mactionViewTexte->setCheckable(true);
//Bar de statue
QStatusBar* statusBar = new QStatusBar;
statusBar->addWidget(new QLabel("Projet Lo21 - Pauline Crouillère / Emilien Notarianni"));
this->setStatusBar(statusBar);
// Création de la barre d'outils
QToolBar *toolBarFichier = addToolBar("Fichier");
toolBarFichier->addAction(mactionNewArticle);
toolBarFichier->addAction(mactionNewImage);
toolBarFichier->addAction(mactionNewAudio);
toolBarFichier->addAction(mactionNewVideo);
toolBarFichier->addAction(mactionNewDocument);
toolBarFichier->addSeparator();
toolBarFichier->addAction(mactionAddTag);
toolBarFichier->addSeparator();
toolBarFichier->addAction(mactionUp);
toolBarFichier->addAction(mactionDown);
toolBarFichier->addSeparator();
toolBarFichier->addAction(mactionExportHTML);
toolBarFichier->addAction(mactionExportTex);
toolBarFichier->addAction(mactionExportTexte);
toolBarFichier->addSeparator();
toolBarFichier->addAction(mactionRestaurer);
toolBarFichier->addSeparator();
toolBarFichier->addAction(mactionSupprimer);
toolBarFichier->addSeparator();
toolBarFichier->addAction(actionQuitter);
/*************************************************************/
couche = new QHBoxLayout();
lw = new LeftWindows();
ow = new OngletWindows();
couche->addWidget(lw);
couche->addWidget(ow);
couche->setMargin(0);
couche->setAlignment(Qt::AlignTop);
centerWindows = new QWidget();
centerWindows->setLayout(couche);
setCentralWidget(centerWindows);
//************************** CONNECT **************************/
QObject::connect(mactionNewArticle, SIGNAL(triggered()), this, SLOT(newArticle()));
QObject::connect(mactionNewDocument, SIGNAL(triggered()), this, SLOT(newDocument()));
QObject::connect(mactionNewImage, SIGNAL(triggered()), this, SLOT(newImage()));
QObject::connect(mactionNewAudio, SIGNAL(triggered()), this, SLOT(newAudio()));
QObject::connect(mactionNewVideo, SIGNAL(triggered()), this, SLOT(newVideo()));
QObject::connect(mactionAddTag, SIGNAL(triggered()), this, SLOT(newTag()));
QObject::connect(mactionOuvrir,SIGNAL(triggered()),this, SLOT(ouvrirDialogue()));
QObject::connect(actionQuitter,SIGNAL(triggered()),qApp, SLOT(quit()));
QObject::connect(mactionUp,SIGNAL(triggered()),this, SLOT(docUp()));
QObject::connect(mactionDown,SIGNAL(triggered()),this, SLOT(docDown()));
QObject::connect(mactionRestaurer, SIGNAL(triggered()), this, SLOT(ouvrirCorbeille()));
QObject::connect(mactionSave, SIGNAL(triggered()), this, SLOT(asave()));
QObject::connect(mactionExportHTML, SIGNAL(triggered()), this, SLOT(exportHTML()));
QObject::connect(mactionExportTex, SIGNAL(triggered()), this, SLOT(exportTex()));
QObject::connect(mactionExportTexte, SIGNAL(triggered()), this, SLOT(exportTexte()));
QObject::connect(mactionSupprimer, SIGNAL(triggered()), this, SLOT(deleteInCorbeille()));
QObject::connect(mactionVider, SIGNAL(triggered()), this, SLOT(viderLaCorbeille()));
//TODO
QObject::connect(mactionAnnuler, SIGNAL(triggered()), qApp, SLOT(undo()));
QObject::connect(mactionRefaire, SIGNAL(triggered()), qApp, SLOT(redo()));
//
QObject::connect(mactionSaveAs, SIGNAL(triggered()), this, SLOT(copieWorkSpace()));
QObject::connect(mactionNew, SIGNAL(triggered()), this, SLOT(newWorkSpace()));
QObject::connect(mactionOption, SIGNAL(triggered()), this, SLOT(setting()));
QObject::connect(mactionViewEdit, SIGNAL(triggered()), this, SLOT(changeEdit()));
QObject::connect(mactionViewHTML, SIGNAL(triggered()), this, SLOT(changeHtml()));
QObject::connect(mactionViewTex,SIGNAL(triggered()),this, SLOT(changeTex()));
QObject::connect(mactionViewTexte,SIGNAL(triggered()),this, SLOT(changeTexte()));
QObject::connect(ow, SIGNAL(currentChanged(int)), this, SLOT(changeOnglet(int)));
QObject::connect(mactionSupprimerTag, SIGNAL(triggered()), this, SLOT(supprimeTag()));
}
static void convertNode(TidyNode node, int level, bool opentag)
{
ctmbstr name;
TidyAttr tattr;
struct htmlTag *t;
int nattr; /* number of attributes */
int i;
switch (tidyNodeGetType(node)) {
case TidyNode_Text:
name = "Text";
break;
case TidyNode_Start:
case TidyNode_End:
case TidyNode_StartEnd:
name = tidyNodeGetName(node);
break;
default:
return;
}
t = newTag((char *)name);
if (!t)
return;
if (!opentag) {
t->slash = true;
return;
}
/* if a js script, remember the line number for error messages */
if (t->action == TAGACT_SCRIPT)
t->js_ln = tidyNodeLine(node);
/* this is the open tag, set the attributes */
/* special case for text tag */
if (t->action == TAGACT_TEXT) {
TidyBuffer tnv = { 0 }; /* text-node value */
tidyBufClear(&tnv);
tidyNodeGetValue(tdoc, node, &tnv);
if (tnv.size) {
t->textval = cloneString(tnv.bp);
tidyBufFree(&tnv);
}
}
nattr = 0;
tattr = tidyAttrFirst(node);
while (tattr != NULL) {
++nattr;
tattr = tidyAttrNext(tattr);
}
t->attributes = allocMem(sizeof(char *) * (nattr + 1));
t->atvals = allocMem(sizeof(char *) * (nattr + 1));
i = 0;
tattr = tidyAttrFirst(node);
while (tattr != NULL) {
t->attributes[i] = cloneString(tidyAttrName(tattr));
t->atvals[i] = cloneString(tidyAttrValue(tattr));
++i;
tattr = tidyAttrNext(tattr);
}
t->attributes[i] = 0;
t->atvals[i] = 0;
/* innerHTML, only for certain tags */
if (t->info->bits & TAG_INNERHTML) {
TidyBuffer tnv = { 0 }; /* text-node value */
tidyBufClear(&tnv);
t->innerHTML = emptyString;
tidyNodeGetText(tdoc, node, &tnv);
if (tnv.size) {
/* But it's not the original html, it has been sanitized.
* Put a cap on size, else memory consumed could, theoretically,
* grow as the size of the document squared. */
if (tnv.size <= 4096)
t->innerHTML = cloneString(tnv.bp);
tagStrip(t->innerHTML);
tidyBufFree(&tnv);
}
}
} /* convertNode */
int cond::MigrateUtilities::execute(){
std::string newTag("");
std::string tag("");
if( hasOptionValue("tag")) {
tag = getOptionValue<std::string>("tag");
if( hasOptionValue("newTag")) newTag = getOptionValue<std::string>("newTag");
}
bool debug = hasDebug();
std::string destConnect = getOptionValue<std::string>("destConnect" );
std::string sourceConnect = getOptionValue<std::string>("sourceConnect");
std::tuple<std::string,std::string,std::string> connPars = parseConnectionString( sourceConnect );
if( std::get<0>( connPars ) == "frontier" ) throwException("Cannot migrate data from FronTier cache.","MigrateUtilities::execute");
std::cout <<"# Connecting to source database on "<<sourceConnect<<std::endl;
cond::DbSession sourcedb = openDbSession( "sourceConnect", cond::Auth::COND_READER_ROLE, true );
if(debug){
std::cout << "tag " << tag << std::endl;
}
sourcedb.transaction().start( true );
cond::MetaData metadata(sourcedb);
std::vector<std::string> tagToProcess;
if( !tag.empty() ){
tagToProcess.push_back( tag );
} else {
metadata.listAllTags( tagToProcess );
}
persistency::ConnectionPool connPool;
std::cout <<"# Opening session on destination database..."<<std::endl;
persistency::Session session = connPool.createSession( destConnect, true );
session.transaction().start( false );
if( !session.existsDatabase() ) session.createDatabase();
session.transaction().commit();
std::cout <<"# "<<tagToProcess.size()<<" tag(s) to process."<<std::endl;
std::cout <<std::endl;
size_t nt = 0;
size_t tid = 0;
for( auto t : tagToProcess ){
tid++;
std::cout <<"--> Processing tag["<<tid<<"]: "<<t<<std::endl;
session.transaction().start( false );
std::string destTag("");
if( session.checkMigrationLog( sourceConnect, t, destTag ) ){
std::cout <<" Tag already migrated." << std::endl;
session.transaction().rollback();
continue;
}
destTag = t;
if( !newTag.empty() ){
destTag = newTag;
} else {
if( session.existsIov( destTag ) ){
destTag = destTag+"["+std::get<1>( connPars )+"/"+std::get<2>( connPars )+"]";
std::cout <<" Tag "<<t<<" already existing, renamed to "<<destTag<<std::endl;
}
}
if( session.existsIov( destTag ) ){
session.transaction().rollback();
throwException("Tag \""+destTag+"\" already exists.","MigrateUtilities::execute");
}
std::cout <<" Resolving source tag oid..."<<std::endl;
std::string iovTok = metadata.getToken(t);
if(iovTok.empty()){
session.transaction().rollback();
throw std::runtime_error(std::string("tag ")+t+std::string(" not found") );
}
std::map<std::string,Hash> tokenToHash;
size_t niovs = 0;
std::set<Hash> pids;
persistency::IOVEditor editor;
std::cout <<" Loading source tag..."<<std::endl;
try{
cond::IOVProxy sourceIov(sourcedb, iovTok);
int tt = (int) sourceIov.timetype();
if( sourceIov.size() == 0 ) {
std::cout <<" No iov found. Skipping tag."<<std::endl;
session.transaction().rollback();
continue;
}
std::string payloadType("");
if( sourceIov.payloadClasses().size() > 0 ) {
payloadType = *(sourceIov.payloadClasses().begin());
} else {
std::string tk = sourceIov.begin()->token();
payloadType = sourcedb.classNameForItem( tk );
}
std::cout <<" Importing tag. Size:"<<sourceIov.size()<<" timeType:"<<cond::timeTypeNames(tt)<<" payloadObjectType=\""<<payloadType<<"\""<<std::endl;
editor = session.createIov( payloadType, destTag, (cond::TimeType)tt );
editor.setDescription( "Tag "+t+" migrated from "+sourceConnect );
for( auto iov : sourceIov ){
Time_t s = iov.since();
std::string tok = iov.token();
Hash pid("");
auto f = tokenToHash.find( tok );
if( f == tokenToHash.end() ){
if(hasDebug() ) std::cout <<"Debug: fetching object for iov ["<<niovs+1<<"] oid: \""<<t<<"\" from source database"<<std::endl;
ora::Object obj = sourcedb.getObject( tok );
if(hasDebug() ) std::cout <<"Debug: importing object into destination database"<<std::endl;
pid = import( obj.typeName(), obj.address(), session );
tokenToHash.insert( std::make_pair( tok, pid ) );
obj.destruct();
} else {
pid= f->second;
}
pids.insert( pid );
editor.insert( s, pid );
niovs++;
if( niovs && (niovs%1000==0) ) std::cout <<" Total of iov inserted: "<<niovs<<std::endl;
}
std::cout <<" Total of iov inserted: "<<niovs<<std::endl;
std::cout <<" Flushing changes..."<<std::endl;
editor.flush();
session.addToMigrationLog( sourceConnect, t, destTag );
session.transaction().commit();
std::cout <<" Tag \""<<t<<"\" imported. Payloads:"<<pids.size()<<" IOVs:"<<niovs<<std::endl;
nt++;
} catch ( const std::exception& e ){
std::cout <<" ERROR:"<<e.what()<<std::endl;
std::cout <<" Tag "<<t<<" will be skipped."<<std::endl;
session.transaction().rollback();
continue;
}
}
std::cout <<"# "<<nt<<" tag(s) migrated."<<std::endl;
sourcedb.transaction().commit();
return 0;
}
static void rebuildSelector(struct htmlTag *sel, jsobjtype oa, int len2)
{
int i1, i2, len1;
bool check2;
char *s;
const char *selname;
bool changed = false;
struct htmlTag *t;
jsobjtype oo; /* option object */
len1 = cw->numTags;
i1 = i2 = 0;
selname = sel->name;
if (!selname)
selname = "?";
debugPrint(4, "testing selector %s %d %d", selname, len1, len2);
sel->lic = (sel->multiple ? 0 : -1);
while (i1 < len1 && i2 < len2) {
/* there is more to both lists */
t = tagList[i1++];
if (t->action != TAGACT_OPTION)
continue;
if (t->controller != sel)
continue;
/* find the corresponding option object */
if ((oo = get_array_element_object(oa, i2)) == NULL) {
/* Wow this shouldn't happen. */
/* Guess I'll just pretend the array stops here. */
len2 = i2;
--i1;
break;
}
t->jv = oo; /* should already equal oo */
t->rchecked = get_property_bool(oo, "defaultSelected");
check2 = get_property_bool(oo, "selected");
if (check2) {
if (sel->multiple)
++sel->lic;
else
sel->lic = i2;
}
++i2;
if (t->checked != check2)
changed = true;
t->checked = check2;
s = get_property_string(oo, "text");
if (s && !t->textval || !stringEqual(t->textval, s)) {
nzFree(t->textval);
t->textval = s;
changed = true;
} else
nzFree(s);
s = get_property_string(oo, "value");
if (s && !t->value || !stringEqual(t->value, s)) {
nzFree(t->value);
t->value = s;
} else
nzFree(s);
}
/* one list or the other or both has run to the end */
if (i2 == len2) {
for (; i1 < len1; ++i1) {
t = tagList[i1];
if (t->action != TAGACT_OPTION)
continue;
if (t->controller != sel)
continue;
/* option is gone in js, disconnect this option tag from its select */
t->jv = 0;
t->controller = 0;
t->action = TAGACT_NOP;
changed = true;
}
} else if (i1 == len1) {
for (; i2 < len2; ++i2) {
if ((oo = get_array_element_object(oa, i2)) == NULL)
break;
t = newTag("option");
t->lic = i2;
t->controller = sel;
t->jv = oo;
t->step = 2; // already decorated
t->textval = get_property_string(oo, "text");
t->value = get_property_string(oo, "value");
t->checked = get_property_bool(oo, "selected");
if (t->checked) {
if (sel->multiple)
++sel->lic;
else
sel->lic = i2;
}
t->rchecked = get_property_bool(oo, "defaultSelected");
changed = true;
}
}
if (!changed)
return;
debugPrint(4, "selector %s has changed", selname);
/* If js change the menu, it should have also changed select.value
* according to the checked options, but did it?
* Don't know, so I'm going to do it here. */
s = displayOptions(sel);
if (!s)
s = emptyString;
set_property_string(sel->jv, "value", s);
javaSetsTagVar(sel->jv, s);
nzFree(s);
if (!sel->multiple)
set_property_number(sel->jv, "selectedIndex", sel->lic);
} /* rebuildSelector */
int main (int argc, char **argv) {
int c,
errflg = 0;
Dbptr db, tr;
char *database,*outfile, *pfname=0;
Flags flags ;
Pf *pf,*pf_def,*pf_sta=NULL,*pf_stas;
Tbl *input;
char *start, *stop, *triggertimestring=NULL ;
char *subset=0 ;
long nrecords,nsamp1 ;
int duration,nframes,sampsperframe;
double tstart, tstop, triggertime=0;
char sta[STA_LEN],sta1[STA_LEN];
char chan[STA_LEN],chan1[STA_LEN];
double samprate,samprate1,t1,t2;
FILE *fout;
size_t nw;
unsigned char *hdrbuf=malloc(2040);
unsigned char *framebuf=malloc(32);
unsigned char *tagbuf=malloc(16);
unsigned short cksum;
unsigned char wfarr[3 * 12 * 100]; /*1000sps * 0.1 sec * 12 chan * 3bytes*/
int sampindex=0;
K2EvtFile *myhdr=malloc(2040);
K2EvtTag *mytag=malloc(sizeof(K2EvtTag));
K2EvtFrame *myframe=malloc(sizeof(K2EvtFrame));
float *data[12] ;
unsigned short channelBitmap=0;
int pf_serialno,pf_sensortype;
double pf_sensitivity, pf_fullscale, pf_lat, pf_lon, pf_elev;
memset ( &flags, 0, sizeof(flags));
elog_init ( argc, argv ) ;
while ((c = getopt (argc, argv, "do:p:s:t:v")) != -1) {
switch (c) {
case 'd':
flags.display = 1 ;
break ;
case 'p':
pfname= optarg ;
break;
case 's':
subset = optarg ;
break ;
case 't':
triggertimestring = optarg ;
break ;
case 'v':
flags.verbose++ ;
break;
default:
errflg++;
break ;
}
}
if (errflg || argc-optind != 4)
usage ();
if (pfname==NULL) {
pfname=Program_Name;
}
if (pfread (pfname, &pf) != 0)
die (0, "Can't read parameter file %s\n",pfname);
database = argv[optind++];
outfile = argv[optind++];
start = argv[optind++];
stop = argv[optind++];
tstart=str2epoch(start);
tstop=str2epoch(stop);
tstart=ceil(tstart); /* make sure we have second boundaries,
this also makes sure we have a integer number of frames */
tstop=floor(tstop);
duration=tstop - tstart;
if ( dbopen(database, "r", &db) ) {
die ( 0, "Can't open database %s", database ) ;
}
input = pfget_tbl (pf, "view" ) ;
db = dbprocess ( db, input, 0 ) ;
if (subset) {
db=dbsubset(db,subset,0);
}
tr = dbinvalid() ;
if ( trload_css ( db, start, stop, &tr, 0, 0 ) ) {
die ( 1, "trload_css failed" ) ;
}
if ( trsplit(tr, 0, 0) ) {
complain ( 0, "trsplit failed" ) ;
}
if ( trsplice(tr, 0, 0, 0) ) {
complain ( 0, "trsplice failed" ) ;
}
if ( flags.display ) {
trdisp (tr, "will try to convert this stuff to evt") ;
}
tr.record=0;
dbgetv(tr,0,"time",&t1,"endtime",&t2,"sta",sta1,"chan",chan1,"samprate",&samprate1,"nsamp",&nsamp1,NULL);
samprate1=round(samprate1);
dbquery ( tr, dbRECORD_COUNT, &nrecords ) ;
if (nrecords > 12) {
printf("will only use the first 12 channels, consider modifying the subset...");
nrecords=12;
}
for ( tr.record = 0 ; tr.record < nrecords ; tr.record++ ) {
double ts,te;
dbgetv(tr,0,"time",&ts,"endtime",&te,"samprate",&samprate,"sta",sta,"chan",chan,NULL);
samprate=round(samprate);
if (t1 != ts || t2 != te) {
die ( 0, "this simplistic version only works with 101% correct times and/or subsets, sorry..." ) ;
}
if (strcmp(sta,sta1) !=0) {
die ( 0, "%s <=> %s this simplistic version only works with ONE station, but the subset left more",sta,sta1 ) ;
}
if (samprate != samprate1) {
die ( 0, "all channels in a K2-EVT File MUST have the same samplerate!" );
}
}
newFileHeader(&myhdr, pf, sta);
if (parse_param (pf, "sta_defaults", P_ARRPF, 1, &pf_def) < 0) {
elog_die (0, "error parsing array sta_defaults.\n");
}
if (parse_param (pf, "sta_params", P_ARRPF, 1, &pf_stas) < 0) {
elog_die (0, "error parsing array sta_params.\n");
}
if (parse_param (pf_stas, sta, P_ARRPF, 0, &pf_sta) < 0) {
elog_die (0, "error parsing sta_params{%s}\n.",sta);
}
if (parse_param(pf_def,"sensortype",P_LINT,1,&pf_sensortype)< 0 ) {
elog_die (0, "error parsing default sensortype.\n");
}
if (parse_param(pf_def,"serialno",P_LINT,1,&pf_serialno)< 0 ) {
elog_die (0, "error parsing default serialno.\n");
}
if (parse_param(pf_def,"sensitivity",P_DBL,1,&pf_sensitivity)< 0 ) {
elog_die (0, "error parsing default sensitivity.\n");
}
if (parse_param(pf_def,"fullscale",P_DBL,1,&pf_fullscale)< 0 ) {
elog_die (0, "error parsing default fullscale.\n");
}
if (parse_param(pf_def,"lat",P_DBL,1,&pf_lat)< 0 ) {
elog_die (0, "error parsing default lat.\n");
}
if (parse_param(pf_def,"lon",P_DBL,1,&pf_lon)< 0 ) {
elog_die (0, "error parsing default lon.\n");
}
if (parse_param(pf_def,"elev",P_DBL,1,&pf_elev)< 0 ) {
elog_die (0, "error parsing default elev.\n");
}
if (pf_sta==NULL) {
elog_notify (0, "can't parse array sta_params{%s}, will use defaults\n.",sta);
pf_sta=pf_def;
} else {
if (parse_param(pf_def,"sensortype",P_LINT,0,&pf_sensortype)< 0 ) {
elog_die (0, "error parsing sensortype.\n");
}
if (parse_param(pf_sta,"serialno",P_LINT,0,&pf_serialno)< 0 ) {
elog_die (0, "error parsing serialno.\n");
}
if (parse_param(pf_sta,"sensitivity",P_DBL,0,&pf_sensitivity)< 0 ) {
elog_die (0, "error parsing sensitivity.\n");
}
if (parse_param(pf_sta,"fullscale",P_DBL,0,&pf_fullscale)< 0 ) {
elog_die (0, "error parsing fullscale.\n");
}
if (parse_param(pf_sta,"lat",P_DBL,0,&pf_lat)< 0 ) {
elog_die (0, "error parsing lat.\n");
}
if (parse_param(pf_sta,"lon",P_DBL,0,&pf_lon)< 0 ) {
elog_die (0, "error parsing lon.\n");
}
if (parse_param(pf_sta,"elev",P_DBL,0,&pf_elev)< 0 ) {
elog_die (0, "error parsing elev.\n");
}
}
myhdr->rw_stream.sps=samprate; /* sampling rate */
myhdr->rw_stream.preEvent=1; /* in seconds */
myhdr->rw_stream.postEvent=5; /* in seconds */
myhdr->rw_stream.minRunTime=6; /* in seconds */
myhdr->ro_stream.duration=duration;
myhdr->ro_stream.nscans=duration* 10;
myhdr->ro_stream.startTime=epoch2k2time(t1);
myhdr->ro_stream.startTimeMsec=0;
int ttms=0;
if (triggertimestring) {
triggertime=str2epoch(triggertimestring);
ttms=remainder(triggertime,1.0 ) * 1000.0;
triggertime=epoch2k2time(triggertime);
} else {
triggertime=epoch2k2time(t1)+5;
ttms=0;
}
myhdr->ro_stream.triggerTime=triggertime;
myhdr->ro_stream.triggerTimeMsec=ttms;
myhdr->rw_misc.nchannels=nrecords;
for (int channo=0;channo< nrecords;channo++) {
myhdr->rw_channel[channo].sensitivity=pf_sensitivity;
myhdr->rw_channel[channo].sensitivity=pf_fullscale;
}
myhdr->rw_misc.elevation=pf_elev; /* meters above sea level */
myhdr->rw_misc.latitude=pf_lat; /* degrees north */
myhdr->rw_misc.longitude=pf_lon; /* degrees east */
nframes=duration * 10;
myhdr->ro_stream.duration=nframes;
myhdr->ro_stream.nscans=duration*samprate;
channelBitmap=chanbitmap(nrecords);
for ( tr.record = 0 ; tr.record < nrecords ; tr.record++ ) {
unsigned long i ;
int nsamp;
char chan[7];
unsigned long minoffset=0;
unsigned long maxoffset=0;
int max=INT_MIN;
int min=INT_MAX;
dbgetv(tr, 0, "chan",chan,"data", &data[tr.record], "nsamp", &nsamp, NULL ) ;
for ( i=0 ; i<nsamp ; i++ ) {
if (data[tr.record][i] > max) {
max=data[tr.record][i];
maxoffset=i;
}
if (data[tr.record][i] < min) {
min=data[tr.record][i];
minoffset=i;
}
}
myhdr->ro_channel[tr.record].maxPeak=max;
myhdr->ro_channel[tr.record].maxPeakOffset=maxoffset;
myhdr->ro_channel[tr.record].minPeak=min;
myhdr->ro_channel[tr.record].minPeakOffset=minoffset;
memcpy(myhdr->rw_channel[tr.record].id,chan,K2EVT_CHANNEL_ID_LENGTH);
}
for ( tr.record = 0 ; tr.record < nrecords ; tr.record++ ) {
}
newTag(&mytag,0, 2040, 0, 128,1234);
encodek2header(hdrbuf,myhdr);
cksum=k2_checksum(hdrbuf,2040);
mytag->length=2040;/*header size*/
mytag->dataLength=0;
mytag->checksum=cksum;
encodek2tag(tagbuf,mytag);
fout=fopen(outfile,"w+");
nw=fwrite(tagbuf,16,1,fout);
nw=fwrite(hdrbuf,2040,1,fout);
double t=t1 ;
double k2t=round(epoch2k2time(t));
newFrameHeader(&myframe,128,(sampsperframe*3*nrecords)+32, k2t);
sampsperframe=TIME2SAMP(0,samprate,0.1);/*samples per frame*/
for (int fn=0;fn < nframes;fn++) {
cksum=0;
sampindex=0;
for (int s=0;s<sampsperframe;s++) {
long val;
unsigned char buf[4];
for ( int channo = 0 ; channo < nrecords ; channo++ ) {
int index=((fn*sampsperframe) + s);
val=round(data[channo][index]);
/*debugging...*/
//val=66051;/*0x010203*/
memcpy(&buf,&val,4);
val <<=8;
#ifdef WORDS_BIGENDIAN
cksum+=buf[1];
cksum+=buf[2];
cksum+=buf[3];
wfarr[sampindex++]=buf[1];
wfarr[sampindex++]=buf[2];
wfarr[sampindex++]=buf[3];
#else
cksum+=buf[2];
cksum+=buf[1];
cksum+=buf[0];
wfarr[sampindex++]=buf[2];
wfarr[sampindex++]=buf[1];
wfarr[sampindex++]=buf[0];
#endif
}
}
mytag->checksum=cksum;
mytag->length=32;/*header size*/
mytag->dataLength=sampsperframe * nrecords * 3;
myframe->frameSize=(sampsperframe*3*nrecords)+32;
myframe->blockTime=round(k2t);
myframe->msec=fmod(k2t,1.0) * 1000;
myframe->channelBitMap=channelBitmap;
encodek2Frame(framebuf,myframe);
mytag->checksum+=k2_checksum(framebuf,32);
encodek2tag(tagbuf,mytag);
k2t+=0.1;
//k2t=round((k2t+0.1)*10.0)/10.0;
nw=fwrite(tagbuf,1,16,fout);
if (nw!= 16) {
die(0,"could not write file tag, wrote %d bytes instead of 16",nw);
}
nw=fwrite(framebuf,32,1,fout);
nw=fwrite(&wfarr, 1,sampsperframe * 3 * nrecords, fout);
}
fclose(fout);
tr.table = dbALL ;
trfree(tr) ;
pffree(pf) ;
return 0;
}
