root/ossiedev/branches/mcarrick/ossiedev-trunk/components/CarrierDataSource/CarrierDataSource.cpp @ 9308

/****************************************************************************

Copyright 2007 Virginia Polytechnic Institute and State University

This file is part of the OSSIE CarrierDataSource.

OSSIE CarrierDataSource 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.

OSSIE CarrierDataSource 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 OSSIE CarrierDataSource; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

****************************************************************************/


#include <string>
#include <iostream>
#include "CarrierDataSource.h"

CarrierDataSource_i::CarrierDataSource_i(const char *uuid, omni_condition *condition) : 
    Resource_impl(uuid), component_running(condition) 
{
    dataOut_0 = new standardInterfaces_i::complexShort_u("dataOut");

    //Create the thread for the writer's processing function 
    processing_thread = new omni_thread(Run, (void *) this);

    //Start the thread containing the writer's processing function 
    processing_thread->start();

    thread_started = false;

}

CarrierDataSource_i::~CarrierDataSource_i(void)
{   
    delete dataOut_0;
}

// Static function for omni thread
void CarrierDataSource_i::Run( void * data )
{
    ((CarrierDataSource_i*)data)->ProcessData();
}

CORBA::Object_ptr CarrierDataSource_i::getPort( const char* portName ) throw (
    CORBA::SystemException, CF::PortSupplier::UnknownPort)
{
    DEBUG(3, CarrierDataSource, "getPort() invoked with " << portName)
    
    CORBA::Object_var p;

    p = dataOut_0->getPort(portName);

    if (!CORBA::is_nil(p))
        return p._retn();

    /*exception*/
    throw CF::PortSupplier::UnknownPort();
}

void CarrierDataSource_i::start() throw (CORBA::SystemException, 
    CF::Resource::StartError)
{
    DEBUG(3, CarrierDataSource, "start() invoked")

    omni_mutex_lock l(processing_mutex);
    if (false == thread_started){
        thread_started = true;    //initialize
        //Create the thread for the writer's processing function 
        processing_thread = new omni_thread(Run, (void *) this);
        //Start the thread containing the writer's processing function 
        processing_thread->start();
    }
}

void CarrierDataSource_i::stop() throw (CORBA::SystemException, CF::Resource::StopError) 
{  
    DEBUG(3, CarrierDataSource, "stop() invoked")
    omni_mutex_lock l(processing_mutex);
    thread_started=false;
}

void CarrierDataSource_i::releaseObject() throw (CORBA::SystemException,
    CF::LifeCycle::ReleaseError)
{
    DEBUG(3, CarrierDataSource, "releaseObject() invoked")
    
    component_running->signal();
}

void CarrierDataSource_i::initialize() throw (CF::LifeCycle::InitializeError,
    CORBA::SystemException)
{
    DEBUG(3, CarrierDataSource, "initialize() invoked")
}

void CarrierDataSource_i::configure(const CF::Properties& props)
throw (CORBA::SystemException,
    CF::PropertySet::InvalidConfiguration,
    CF::PropertySet::PartialConfiguration)
{
    DEBUG(3, CarrierDataSource, "configure() invoked")
    
    std::cout << "props length : " << props.length() << std::endl;

    for (unsigned int i = 0; i <props.length(); i++)
    {
        std::cout << "Property id : " << props[i].id << std::endl;

    }
}

void CarrierDataSource_i::ProcessData()
{
    DEBUG(3, CarrierDataSource, "ProcessData() invoked")

    PortTypes::ShortSequence I_out_0, Q_out_0;

    int len = 512;

    I_out_0.length(len); //must define length of output
    Q_out_0.length(len); //must define length of output

    for (unsigned int i = 0; i < I_out_0.length(); i++)
    {
        I_out_0[i] = 0;
        Q_out_0[i] = 0;
    }

    while(continue_processing()) {
        dataOut_0->pushPacket(I_out_0, Q_out_0);
        usleep(50*1000);
    }
}

bool CarrierDataSource_i::continue_processing(void)
{
    omni_mutex_lock l(processing_mutex);
    return thread_started;
}