inspectorJ -- JavaTM Profiler

sf project site browse source checkout source

src/inspectorj/toolset/profiletoolset.cpp

Go to the documentation of this file.

/***************************************************************************
 *   inspectorJ - java profiler                                            *
 *   Copyright (C) 2007 by James May
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include "profiletoolset.h"

namespace inspectorj {
namespace toolset {

using inspectorj::client::SessionProfile;

ProfileToolSet::ProfileToolSet()
{
}


ProfileToolSet::~ProfileToolSet()
{
}


bool ProfileToolSet::loadProfile(inspectorj::client::SessionProfile& profile, QString fileName) {
    return ProfileToolSet::loadProfile(profile, fileName.toLocal8Bit().data());
}

bool ProfileToolSet::loadProfile(inspectorj::client::SessionProfile& profile, char *fileName)
{
    // load a profile from an xml document
    TiXmlDocument doc(fileName);
    if (doc.LoadFile()) {

        TiXmlHandle hDoc(&doc);
        TiXmlElement* elem;
        TiXmlHandle hRoot(0); 
               
        elem = hDoc.FirstChildElement().Element();
        // should always have a valid root but handle gracefully if it does
        if (!elem) return false;

        hRoot = TiXmlHandle(elem);  
              
        // make sure we have the profile element
        elem = hRoot.FirstChild("profile").Element();
        if (!elem) return false;
        profile.setName(QString(elem->Attribute("name")));
        profile.setFileName(QString(elem->Attribute("file-name")));
        hRoot = TiXmlHandle(elem);
        
        // set the profile's ijConnection
        elem = hRoot.FirstChild("connection").Element();
        if (elem)
        {
            inspectorj::client::ijConnection conn;
            conn.host = elem->Attribute("host");
            conn.port = elem->Attribute("port");
            profile.setConnection(conn);
        } else { return false; }   
         
        // set the profile's jreHome
        elem = hRoot.FirstChild("jre-home").Element();
        if (elem)
        {
            QString jreHome(elem->GetText());
            profile.setJreHome(jreHome);
        } else { return false; }  
        
        // set the profile's javaOptions
        elem = hRoot.FirstChild("java-options").Element();
        if (elem)
        {
            QString javaOptions(elem->GetText());
            profile.setJavaOptions(javaOptions);
        }  else { return false; }       
         
        // set the profile's applicationArgs
        elem = hRoot.FirstChild("application-args").Element();
        if (elem)
        {
            QString appArgs(elem->GetText());
            profile.setApplicationArgs(appArgs);
        } else { return false; }  
                
        // set the profile's applicationEntry
        elem = hRoot.FirstChild("application-entry").Element();
        if (elem)
        {
            QString applicationEntry(elem->GetText());
            profile.setApplicationEntry(applicationEntry);
        } else { return false; }  
                 
        // set the profile's jarFile attribute
        elem = hRoot.FirstChild("jar-file").Element();
        if (elem)
        {
            QString jarFile(elem->GetText());
            if (!jarFile.isEmpty() && jarFile == "true") {
                profile.setJarFile(true);
            } else {
                profile.setJarFile(false);
            }
        } else { return false; }  
        
        // set the profile's tomcatApp attribute
        elem = hRoot.FirstChild("tomcat-application").Element();
        if (elem)
        {
            QString tomcatApp(elem->GetText());
            if (!tomcatApp.isEmpty() && tomcatApp == "true") {
                profile.setTomcatApp(true);
            } else {
                profile.setTomcatApp(false);
            }
        } else { return false; }         
            
        // set the profile's externalLaunch attribute
        elem = hRoot.FirstChild("external-launch").Element();
        if (elem)
        {
            QString extLaunch(elem->GetText());
            if (!extLaunch.isEmpty() && extLaunch == "true") {
                profile.setExternalLaunch(true);
            } else {
                profile.setExternalLaunch(false);
            }
        } else { return false; }   
             
        // set the profile's classPath list
        elem = hRoot.FirstChild("classpath").Element();
        if (elem)
        {
            TiXmlHandle cpRoot(elem);
            elem = cpRoot.FirstChild("entry").Element();
            QStringList classPaths;
            while (elem) {
                QString cpEntry(elem->GetText());
                classPaths << cpEntry;
                elem = elem->NextSiblingElement();
            }
            profile.setClassPath(classPaths);
        } else { return false; }   
        
        // set the profile's classFilter list
        elem = hRoot.FirstChild("classfilter").Element();
        if (elem)
        {
            TiXmlHandle cfRoot(elem);
            elem = cfRoot.FirstChild("entry").Element();
            QStringList classFilters;
            while (elem) {
                QString cfEntry(elem->GetText());
                classFilters << cfEntry;
                elem = elem->NextSiblingElement();
            }
            profile.setClassFilters(classFilters);
        } else { return false; }  
                                        
        return true;
    } else {
        return false;
    }
}

bool ProfileToolSet::saveProfile(inspectorj::client::SessionProfile &profile, QString dir)
{
    // create document and declaration
    QList<void *> ptrs;
    TiXmlDocument doc;
    TiXmlDeclaration *decl = new TiXmlDeclaration ( "1.0", "", "" );  
    doc.LinkEndChild( decl ); 
         
    // create inspectorj root element
    TiXmlElement *root = new TiXmlElement ("inspectorj");
    doc.LinkEndChild(root);

    // create comment
    TiXmlComment *comment = new TiXmlComment();
    comment->SetValue(" Session Profile for inspectorJ " );  
    root->LinkEndChild( comment );     
    
    // create profile element
    TiXmlElement *prof = new TiXmlElement ("profile"); 
    prof->SetAttribute("name", profile.getName().toLocal8Bit().data());
    prof->SetAttribute("file-name", profile.getFileName().toLocal8Bit().data());   
    root->LinkEndChild( prof ); 
    
    // create connection element
    TiXmlElement *conn = new TiXmlElement ("connection"); 
    conn->SetAttribute("host", profile.getConnection().host.toLocal8Bit().data());    
    conn->SetAttribute("port", profile.getConnection().port.toLocal8Bit().data()); 
    prof->LinkEndChild( conn );
        
    // create jreHome element
    TiXmlElement *jreHome = new TiXmlElement ("jre-home"); 
    TiXmlText *jreHomeText = new TiXmlText (profile.getJreHome().toLocal8Bit().data());
    jreHome->LinkEndChild(jreHomeText);
    prof->LinkEndChild( jreHome );  

    // create java options element
    TiXmlElement *javaOptions = new TiXmlElement ("java-options"); 
    TiXmlText *javaOptionsText = new TiXmlText (profile.getJavaOptions().toLocal8Bit().data());
    javaOptions->LinkEndChild(javaOptionsText);
    prof->LinkEndChild( javaOptions );  
    
    // create application args element
    TiXmlElement *applicationArgs = new TiXmlElement ("application-args"); 
    TiXmlText *applicationArgsText = new TiXmlText (profile.getApplicationArgs().toLocal8Bit().data());
    applicationArgs->LinkEndChild(applicationArgsText);
    prof->LinkEndChild( applicationArgs ); 

    // create java entry element
    TiXmlElement *applicationEntry = new TiXmlElement ("application-entry"); 
    TiXmlText *applicationEntryText = new TiXmlText (profile.getApplicationEntry().toLocal8Bit().data());
    applicationEntry->LinkEndChild(applicationEntryText);
    prof->LinkEndChild( applicationEntry );
        
    // create jar file element
    TiXmlElement *jarFile = new TiXmlElement ("jar-file"); 
    TiXmlText *jarFileText = new TiXmlText (profile.isJarFile() ? "true" : "false");
    jarFile->LinkEndChild(jarFileText);
    prof->LinkEndChild( jarFile );
    
    // create tomcatApp element
    TiXmlElement *tomcatApp = new TiXmlElement ("tomcat-application"); 
    TiXmlText *tomcatAppText = new TiXmlText (profile.isTomcatApp() ? "true" : "false");
    tomcatApp->LinkEndChild(tomcatAppText);
    prof->LinkEndChild( tomcatApp );    
    
    // create external launch element
    TiXmlElement *externalLaunch = new TiXmlElement ("external-launch"); 
    TiXmlText *externalLaunchText = new TiXmlText (profile.isExternalLaunch() ? "true" : "false");
    externalLaunch->LinkEndChild(externalLaunchText);
    prof->LinkEndChild( externalLaunch );    
        
    // create classpath element and entries
    TiXmlElement *classPath = new TiXmlElement ("classpath");
    TiXmlElement *classPathEntry;
    TiXmlText *classPathText;
    QStringList cpList = profile.getClassPath();
    for (int i = 0; i < cpList.size(); ++i) {
        classPathEntry = new TiXmlElement ("entry");
        classPathText = new TiXmlText(cpList.at(i).toLocal8Bit().data());
        classPathEntry->LinkEndChild(classPathText);
        classPath->LinkEndChild(classPathEntry);
    }
    prof->LinkEndChild( classPath );  

    // create classfilter element and entries
    TiXmlElement *classFilter = new TiXmlElement ("classfilter");
    TiXmlElement *classFilterEntry;
    TiXmlText *classFilterText;
    QStringList filterList = profile.getClassFilters();
    for (int i = 0; i < filterList.size(); ++i) {
        classFilterEntry = new TiXmlElement ("entry");
        classFilterText = new TiXmlText(filterList.at(i).toLocal8Bit().data());
        classFilterEntry->LinkEndChild(classFilterText);
        classFilter->LinkEndChild(classFilterEntry);
    }
    prof->LinkEndChild( classFilter ); 
    
    QString filePath = dir.append(QDir::separator());
    QString fileName = profile.getFileName();
    if (fileName.isEmpty()) {
        fileName = profile.getName();
    }
    filePath.append(fileName);
    return doc.SaveFile(filePath.toLocal8Bit().data());

}



}
}

---