phPowerData.cpp

Go to the documentation of this file.

#include <phPowerData.h>
#include <phbase.h>
    
/* ------------------------------------------------------------------------ */
phPowerData::phPowerData()
{
    phFUNCTION("phPowerData::phPowerData")
    int locked = 0;
    int rwlocked = 0;
    
    phTHIS_LOOSE_LOCK(locked);
    phTHIS_WRITELOCK_LOOSE(rwlocked);
    
    this->setName("phPowerData");
    
    this->m_charge  = 0;

    phTHIS_RWUNLOCK_LOOSE(rwlocked);
    phTHIS_LOOSE_UNLOCK(locked);
}

/* ------------------------------------------------------------------------ */
int phPowerData::copy( phObject *copyto_object )
{
    phFUNCTION("phPowerData::copy")
    
    if (this->isNamed(((phObject *)copyto_object)->getName()))
    {
        phPowerData *copyto_data = (phPowerData *)copyto_object;
        return copyto_data->copyData(*this);
    }
    /* Otherwise I'll assume they are incompatible */
    else
    {
        phPRINT_RC(-1,NULL, "Invalid object pairing in update."
                          "[ this:%s != target:%s ]",
                 this->getName(), ((phObject *)copyto_object)->getName());
        return phFAIL;
    }
}

/* ------------------------------------------------------------------------ */
int phPowerData::swap( phObject *object )
{
    phFUNCTION("phPowerData::swap")

    if (this->isNamed(((phObject *)object)->getName()))
    {
        phPowerData *data = (phPowerData *)object;

        return data->swapData(*this);
    }
    /* Otherwise I'll assume they are incompatible */
    else
    {
        phPRINT_RC(-1,NULL, "Invalid object pairing in update."
                          "[ this:%s != target:%s ]",
                 this->getName(), ((phObject *)object)->getName());
        return phFAIL;
    }    
}

/* ------------------------------------------------------------------------ */
int phPowerData::copyData( phPowerData &copyfrom )
{
    phFUNCTION("phPowerData::copyData")
    int rwlocked = 0;
    int other_rwlocked = 0;
   
    phTHIS_WRITELOCK(rwlocked);
    phREADLOCK(copyfrom,other_rwlocked);
    
    this->m_charge = copyfrom.m_charge;

    rc = this->notify();
    phPRINT_RC(rc,NULL,"this->notify()");

    phRWUNLOCK(copyfrom,other_rwlocked);
    phTHIS_RWUNLOCK(rwlocked);

    return phSUCCESS;
error:
    phRWUNLOCK_ERROR(copyfrom,other_rwlocked);
    phTHIS_RWUNLOCK_ERROR(rwlocked);
    
    return phFAIL;    
}

/* ------------------------------------------------------------------------ */
int phPowerData::swapData( phPowerData &data )
{
    phFUNCTION("phPowerData::swapData")
    int rwlocked = 0;
    int other_rwlocked = 0;
    double t_charge    = 0;

    phTHIS_WRITELOCK(rwlocked);
        
    if (this->isSwapEnabled())
    {
        phWRITELOCK(data,other_rwlocked);
    
        t_charge = data.m_charge;
 
        data.m_charge = this->m_charge;

        this->m_charge = t_charge;

        rc = this->notify();
        phPRINT_RC(rc,NULL,"this->notify()");

        rc = data.notify();
        phPRINT_RC(rc,NULL,"data.notify()");

        phRWUNLOCK(data,other_rwlocked);
    }
    else
    {
        rc = this->copyData(data);
        phCHECK_RC(rc,NULL,"this->copyData(data)");
    }
    phTHIS_RWUNLOCK(rwlocked);

    return phSUCCESS;
error:
    phRWUNLOCK_ERROR(data,other_rwlocked);
    phTHIS_RWUNLOCK_ERROR(rwlocked);

    return phFAIL;    
}

/* ------------------------------------------------------------------------ */
int phPowerData::reset()
{
    phFUNCTION("phPowerData::reset")
    int rwlocked = 0;

    phTHIS_WRITELOCK(rwlocked);

    this->m_charge      = 0;
   
    phTHIS_RWUNLOCK_RET(rwlocked,phSUCCESS,phFAIL);
}


/* ------------------------------------------------------------------------ */
int phPowerData::set(double charge)
{
    phFUNCTION("phPowerData::set")
    int rwlocked = 0;
    
    phTHIS_WRITELOCK(rwlocked);
        
    this->m_charge  = charge;

    rc = this->notify();
    phPRINT_RC(rc,NULL,"this->notify()");

    phTHIS_RWUNLOCK_RET(rwlocked,phSUCCESS,phFAIL);
}

/* ------------------------------------------------------------------------ */
int phPowerData::get(double *charge)
{
    phFUNCTION("phPowerData::get")
    int rwlocked = 0;

    phTHIS_READLOCK(rwlocked);

    if (charge != NULL)
        *charge = this->m_charge;

    phTHIS_RWUNLOCK_RET(rwlocked,phSUCCESS,phFAIL);
}

/* ------------------------------------------------------------------------ */
double phPowerData::getCharge(  )
{
    phFUNCTION("phPowerData::getCharge")
    int rwlocked = 0;
    double retval = 0;
 
    phTHIS_READLOCK(rwlocked);

    retval = this->m_charge;

    phTHIS_RWUNLOCK_RET(rwlocked,retval,0);
}

/* ------------------------------------------------------------------------ */
void phPowerData::print_data( )
{
    phFUNCTION("phPowerData::print_data")
    int i           = 0;
    int j           = 0;
    int rwlocked    = 0;

    phTHIS_READLOCK_LOOSE(rwlocked);
    
    fprintf(stderr,"----------------------------------------------------\n");
    fprintf(stderr,"%s\n",this->getName());
    fprintf(stderr,"----------------------------------------------------\n");
    fprintf(stderr,"Charge: %0.8f\n",this->m_charge);
    fprintf(stderr,"----------------------------------------------------\n");
    
    phTHIS_RWUNLOCK_LOOSE(rwlocked);
}

Copyright (C) 2002 - 2007

Philip D.S. Thoren ( pthoren@users.sourceforge.net ) University Of Massachusetts at Lowell Robotics Lab

---