---

allocThreadObjectMethod.cpp

/*
 *                         Sun Public License Notice
 *
 * The contents of this file are subject to the Sun Public License
 * Version 1.0 (the "License"); you may not use this file except
 * in compliance with the License. A copy of the License is available
 * at http://www.sun.com/
 *
 * The Original Code is the Java Profiler module.  The Initial Developers
 * of the Original Code are Jan Stola, Pavel Vacha, Michal Pise, Petr Luner,
 * Lukas Petru and Marek Przeczek.
 *
 * Portions created by Jan Stola are Copyright (C) 2000-2001.
 * All Rights Reserved.
 *
 * Portions created by Pavel Vacha are Copyright (C) 2000-2001.
 * All Rights Reserved.
 *
 * Portions created by Michal Pise are Copyright (C) 2000-2001.
 * All Rights Reserved.
 *
 * Portions created by Petr Luner are Copyright (C) 2000-2001.
 * All Rights Reserved.
 *
 * Portions created by Lukas Petru are Copyright (C) 2000-2001.
 * All Rights Reserved.
 *
 * Portions created by Marek Przeczek are Copyright (C) 2000-2001.
 * All Rights Reserved.
 *
 * Contributors: Jan Stola, Pavel Vacha, Michal Pise, Petr Luner,
 *               Lukas Petru and Marek Przeczek.
 */

#include "../alloc/allocThreadObjectMethod.h"
#include "../prof/prof.h"
#include "../alloc/allocThreadMethod.h"
#include "../alloc/allocObjectMethod.h"
#include "../alloc/allocThreadObject.h"
#include "../alloc/allocThreadObjectTrace.h"

#ifdef USE_ALLOCATOR
Allocator AllocThreadObjectMethod::_allocator;
#endif

void AllocThreadObjectMethod::addMemoryStat( jint size) {

        if( !modified()) {
        
                AllocAbstractStatThreadObject::addMemoryStat( size);

                threadMethod->addMemoryStat( size);
                objectMethod->addMemoryStat( size);
                threadObject->addMemoryStat( size);
        }
}

void AllocThreadObjectMethod::subMemoryStat( jint size) {
        
        if( !modified()) {
        
                AllocAbstractStatThreadObject::subMemoryStat( size);

                threadMethod->subMemoryStat( size);
                objectMethod->subMemoryStat( size);
                threadObject->subMemoryStat( size);
        }
}

void AllocThreadObjectMethod::clearFlag() {

        AllocAbstractStatThreadObject::clearFlag();

        objectMethod->clearFlag();
        threadObject->clearFlag();
}

void AllocThreadObjectMethod::deactivate() {

        Prof::prof().activeAllocThreadObjectMethods.removeNoRehash(this); 

        AllocThreadObjectTrace* tot = threadObjectTraces.first();
        while (tot) { 
                tot->deactivate();
                tot = threadObjectTraces.next(tot);
        }
}

const AllocThreadObjectMethodKey& AllocThreadObjectMethod::getKey(AllocThreadObjectMethodKey& key) {
                
        threadObject->thread->getKey(key.envId);
        objectMethod->getKey(key.objectMethodKey);
        return key;
}

int AllocThreadObjectMethod::operator==(const AllocThreadObjectMethodKey& key) {
        
        return (*threadObject->thread == key.envId) && (*objectMethod == key.objectMethodKey);
}

int AllocThreadObjectMethod::hashKey(const AllocThreadObjectMethodKey& key) {

        return Thread::hashKey(key.envId) ^ AllocObjectMethod::hashKey(key.objectMethodKey);
}

int AllocThreadObjectMethod::isActive() {

        return (objectMethod->isActive() &&
                                        threadObject->isActive() &&
                                        threadMethod->isActive());
}

void AllocThreadObjectMethod::setUnchanged() {
                
        IdObject::setUnchanged();
        clearDataChanged();
}

---