/** \file
 *
 *  Contains the LcmUniversalDataWriter class implementation.
 *
 *  Copyright (c) 2007,2008,2009 MBARI
 *  MBARI Proprietary Information.  All Rights Reserved
 *
 */

#include "LcmUniversalDataWriter.h"
#include "component/Component.h"
#include "data/UniversalDataElement.h"

LcmUniversalDataWriter::LcmUniversalDataWriter( Component* owner,
        DataElement& element,
        UniversalDataElement* universal,
        Logger::TimePrecisionType timePrecision,
        Str source,
        Str channel,
        LcmPolicy *policy )
    :
    UniversalDataWriter( owner, element, universal, timePrecision ),
    LcmDataWriter( owner, element, universal, timePrecision, source, channel, policy )
{
}

LcmUniversalDataWriter::~LcmUniversalDataWriter()
{
}

// With accuracy

bool LcmUniversalDataWriter::writeWithAccuracy( const Unit& unit, const unsigned char value, const float accuracy, const Timestamp& timestamp )
{
    bool retval = UniversalDataWriter::writeWithAccuracy( unit, value, accuracy, timestamp );

    // create and publish a message
//    retval = (retval && publish((uint8_t *)&value,timestamp, LcmDataWriter::element_.getTypeSize()));

    // TODO: mutex lock the message?
    // set message timestamp
    message_.umsg_.epoch_usec = timestamp.asMicros();
    // set message size
    message_.umsg_.size = LcmDataWriter::element_.getTypeSize();
    // set message data
    message_.umsg_.data = value;
    // create and publish a message
    retval = ( retval && publish( message_, LcmDataWriter::U8 ) );

    // return true if both writes succeed
    return retval;

}
bool LcmUniversalDataWriter::writeWithAccuracy( const Unit& unit, const double value, const float accuracy, const Timestamp& timestamp )
{
    bool retval = UniversalDataWriter::writeWithAccuracy( unit, value, accuracy, timestamp );
    // create and publish a message
//    retval = (retval && publish((uint8_t *)&value,timestamp, LcmDataWriter::element_.getTypeSize()));

    // TODO: mutex lock the message?
    // set message timestamp
    message_.dmsg_.epoch_usec = timestamp.asMicros();
    // set message size
    message_.dmsg_.size = LcmDataWriter::element_.getTypeSize();
    // set message data
    message_.dmsg_.data = value;
    // create and publish a message
    retval = ( retval && publish( message_, LcmDataWriter::DOUBLE ) );

    // return true if both writes succeed
    return retval;
}
bool LcmUniversalDataWriter::writeWithAccuracy( const Unit& unit, const int value, const float accuracy, const Timestamp& timestamp )
{
    bool retval = UniversalDataWriter::writeWithAccuracy( unit, value, accuracy, timestamp );
    // create and publish a message
//    retval = (retval && publish((uint8_t *)&value,timestamp, LcmDataWriter::element_.getTypeSize()));

    // TODO: mutex lock the message?
    // set message timestamp
    message_.imsg_.epoch_usec = timestamp.asMicros();
    // set message size
    message_.imsg_.size = LcmDataWriter::element_.getTypeSize();
    // set message data
    message_.imsg_.data = value;
    // create and publish a message
    retval = ( retval && publish( message_, LcmDataWriter::I32 ) );

    // return true if both writes succeed
    return retval;
}
bool LcmUniversalDataWriter::writeWithAccuracy( const DataValue& value, const float accuracy, const Timestamp& timestamp )
{
    bool retval = UniversalDataWriter::writeWithAccuracy( value, accuracy, timestamp );

    logger_.syslog( "LcmUniversalDataWriter::writeWithAccuracy - DataValue LCM publish not implemented\n", Syslog::IMPORTANT );
    // create and publish a message
    //retval = (retval && publish((uint8_t *)&value,timestamp, LcmDataWriter::element_.getTypeSize()));

    // return true if both writes succeed
    return retval;
}

bool LcmUniversalDataWriter::setAccuracy( const Unit& unit, const float value )
{
    return UniversalDataWriter::setAccuracy( unit, value );
}

float LcmUniversalDataWriter::getAccuracy( const Unit& unit )
{
    return UniversalDataWriter::getAccuracy( unit );
}