inspectorJ -- JavaTM Profiler

sf project site browse source checkout source

src/inspectorj/model/javaclass.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 "inspectorj/model/javaclass.h"

using inspectorj::jdwp::ReferenceTypeID;

namespace inspectorj {
namespace model {

JavaClass::JavaClass()
    : fieldsSet(false), methodsSet(false)
{
}

JavaClass::JavaClass(const JavaClass& otherClass)
{
    refTypeTag = otherClass.refTypeTag;
    refTypeId = otherClass.refTypeId;
    jniClassSignature = otherClass.jniClassSignature;
    classSignature = otherClass.classSignature;
    fields = otherClass.fields;
    methods = otherClass.methods;
    status = otherClass.status;  
}

JavaClass& JavaClass::operator=(const JavaClass& otherClass)
{
    refTypeTag = otherClass.refTypeTag;
    refTypeId = otherClass.refTypeId;
    jniClassSignature = otherClass.jniClassSignature;
    classSignature = otherClass.classSignature;
    fields = otherClass.fields;
    methods = otherClass.methods;
    status = otherClass.status;
    return *this;
}

JavaClass::~JavaClass()
{
    qDeleteAll(fields.begin(), fields.end());
    qDeleteAll(methods.begin(), methods.end());
}

int JavaClass::getStatus()
{
    return status;
}

jbyte JavaClass::getRefTypeTag()
{
    return refTypeTag;
}

ReferenceTypeID& JavaClass::getRefTypeId()
{
    return refTypeId;
}
        
QString JavaClass::getJNIClassSignature()
{
    return jniClassSignature;
}

QString JavaClass::getClassSignature() const
{
    return classSignature;
}

void JavaClass::setRefTypeTag(jbyte refTypeTag)
{
    this->refTypeTag = refTypeTag;
}

void JavaClass::setRefTypeId(ReferenceTypeID refTypeId)
{
    this->refTypeId = refTypeId;
}

void JavaClass::setJNIClassSignature(QString jniSignature)
{
    this->jniClassSignature = jniSignature;
}

void JavaClass::setClassSignature(QString signature)
{
    this-> classSignature = signature;
}

void JavaClass::setStatus(int status)
{
    this->status = status;
}

bool JavaClass::isInitialized()
{
    return methodsSet && fieldsSet;
}

bool JavaClass::isMethodsSet()
{
    return methodsSet;
}

bool JavaClass::isFieldsSet()
{
    return fieldsSet;
}

void JavaClass::addField(JavaField *field)
{
    fields << field;
}

void JavaClass::addMethod(JavaMethod *method)
{
    methods << method;
}

void JavaClass::setFields(JDWPPacket& packet)
{
    if( !ClientPacketHandler::handleJDWPError(packet) ) {    
        int numFields;
        packet >> numFields;
        
        while (numFields > 0) {
            FieldID fieldId;
            QString name;
            QString jniSignature;
            QString signature;
            int modBits;
            
            packet >> fieldId;
            packet >> name;
            packet >> jniSignature;
            packet >> modBits;
            
            JavaField *field = new JavaField();
            field->setFieldId(fieldId);
            field->setFieldName(name);
            field->setJNIFieldSignature(jniSignature);
            field->setFieldSignature(ToolSetUtils::normalizeClassSignature(jniSignature));
            field->setModBits(modBits);
            
            addField(field);
            numFields--;                        
        }
    }
    fieldsSet = true;
    if(methodsSet) {
        emit initialized();
    }
}

void JavaClass::setMethods(JDWPPacket& packet)
{
    if( !ClientPacketHandler::handleJDWPError(packet) ) {
        int numMethods;
        packet >> numMethods;
        QString numStr; 
        while (numMethods > 0) {
            MethodID methodId;
            QString methodName;
            QString jniSignature;
            QString methodSignature;
            int modBits;

            packet >> methodId;
            packet >> methodName;
            packet >> jniSignature;
            packet >> modBits;
            
            JavaMethod *method = new JavaMethod();
            method->setMethodId(methodId);
            method->setMethodName(methodName);
            method->setJNIMethodSignature(jniSignature);
            method->setMethodSignature(ToolSetUtils::normalizeMethodSignature(jniSignature, methodName, getClassSignature()));
            method->setModBits(modBits);
            
            addMethod(method);
            numMethods--;        
        }   
    }  
    methodsSet = true;
    if(fieldsSet) {
        emit initialized();
    }    
}

QList<JavaField*>& JavaClass::getFields()
{
    return fields;
}

QList<JavaMethod*>& JavaClass::getMethods()
{
    return methods;
}

bool JavaClass::operator<(const JavaClass& rhs)
{
    return this->getClassSignature().toLower() < rhs.getClassSignature().toLower(); 
}

bool JavaClass::operator==(const ReferenceTypeID& refTypeId)
{
    return refTypeId.value == refTypeId.value; 
}

bool const JavaClass::operator==(const JavaClass& another)
{
    return refTypeId.value == another.refTypeId.value
            && refTypeTag == another.refTypeTag;   
}

} // end namespace inspectorj
} // end namespace model

---