All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Defines
Public Types | Signals | Public Member Functions | Protected Member Functions
GeopsySLink::SeedLink Class Reference

Brief description of class still missing. More...

#include <SeedLink.h>

List of all members.

Public Types

enum  Error { NoError, StationsNotAvailable, StreamsNotAvailable, FromTimeNotAvailable }

Signals

void dataChanged (Signal *sig, TimeRange tw)
void error (GeopsySLink::SeedLink::Error e)
void infoAvailable ()

Public Member Functions

void addStation (SeedLinkStation *station)
bool addStream (SeedLinkStream *str)
Error error () const
int listeningStreamCount ()
bool removeStream (SeedLinkStream *str)
 SeedLink (QObject *parent=0)
const SeedLinkServer & serverInfo () const
QString serverName () const
quint16 serverPort () const
void setBufferType (SeedLinkStream::BufferType bt)
void setFromTime (QDateTime f)
void setMaximumDuration (double d)
void setServer (QByteArray address, qint16 port)
void start ()
void stations ()
void stop ()
void streams ()
SubSignalPool subPool () const
 ~SeedLink ()

Protected Member Functions

virtual void run ()

Detailed Description

Brief description of class still missing.

Full description of class still missing

Member Enumeration Documentation

enum GeopsySLink::SeedLink::Error
Enumerator:
NoError 
StationsNotAvailable 
StreamsNotAvailable 
FromTimeNotAvailable  
{NoError, StationsNotAvailable, StreamsNotAvailable, FromTimeNotAvailable};

Constructor & Destructor Documentation

GeopsySLink::SeedLink::SeedLink ( QObject *  parent = 0)

Description of constructor still missing

References NoError, GeopsySLink::SeedLinkPrivate::slconn, TRACE, and GeopsySLink::SeedLinkStream::Unlimited.

                                   : QThread(parent)
{
  TRACE;
  _serverPort=18000;
  _internals=new SeedLinkPrivate;
  _internals->slconn=0;
  _bufferType=SeedLinkStream::Unlimited;
  _maximumDuration=0.0;
  if(_instance) {
    qWarning("Only one instance of Seedlink allowed!");
  } else {
    _instance=this;
  }
  _error=NoError;
  qRegisterMetaType<GeopsySLink::SeedLink::Error>();
}
GeopsySLink::SeedLink::~SeedLink ( )

Description of destructor still missing

References GeopsySLink::SeedLinkPrivate::slconn, and TRACE.

{
  TRACE;
  if(_internals->slconn) sl_freeslcd (_internals->slconn);
  delete _internals;
  _instance=0;
}

Member Function Documentation

void GeopsySLink::SeedLink::addStation ( SeedLinkStation *  station) [inline]

Referenced by ConformProcess::start().

{_serverInfo.addStation(station);}
bool GeopsySLink::SeedLink::addStream ( SeedLinkStream *  str)

References QGpCoreTools::endl(), GeopsySLink::SeedLinkStream::setListening(), str, GeopsySLink::SeedLinkStream::tag(), QGpCoreTools::tr(), and TRACE.

Referenced by ConformProcess::start().

{
  TRACE;
  QMutexLocker m(&_mutex);
  _request=Data;
  if(!_listeningStreams.contains(str->tag())) {
    _listeningStreams.insert(str->tag(),str);
    str->setListening(true);
    App::stream() << tr("Listening to stream %1").arg(str->tag().data()) << endl;
    return true;
  } else {
    return false;
  }
}
void GeopsySLink::SeedLink::dataChanged ( Signal *  sig,
TimeRange  tw 
) [signal]
Error GeopsySLink::SeedLink::error ( ) const [inline] 
{return _error;}
void GeopsySLink::SeedLink::error ( GeopsySLink::SeedLink::Error  e) [signal]
void GeopsySLink::SeedLink::infoAvailable ( ) [signal]
int GeopsySLink::SeedLink::listeningStreamCount ( ) [inline] 
{return _listeningStreams.count();}
bool GeopsySLink::SeedLink::removeStream ( SeedLinkStream *  str)

References GeopsySLink::SeedLinkStream::detachSignal(), QGpCoreTools::endl(), GeopsySLink::SeedLinkStream::setListening(), GeopsySLink::SeedLinkStream::tag(), QGpCoreTools::tr(), and TRACE.

{
  TRACE;
  QMutexLocker m(&_mutex);
  _request=Data;
  if(_listeningStreams.contains(str->tag())) {
    _listeningStreams.remove(str->tag());
    str->detachSignal();
    str->setListening(false);
    App::stream() << tr("Stop listening to stream %1").arg(str->tag().data()) << endl;
    return true;
  } else {
    return false;
  }
}
void GeopsySLink::SeedLink::run ( ) [protected, virtual]

References QGpCoreTools::endl(), GeopsyCore::Signal::endTime(), GeopsySLink::SeedLinkStream::location(), GeopsySLink::SeedLinkStation::name(), GeopsySLink::SeedLinkStation::network(), NoError, GeopsySLink::SeedLinkStream::seedName(), GeopsySLink::SeedLinkStream::signal(), GeopsySLink::SeedLinkPrivate::slconn, GeopsySLink::SeedLinkPrivate::slpack, GeopsySLink::SeedLinkStream::station(), GeopsyCore::Signal::timeReference(), QGpCoreTools::tr(), TRACE, and GeopsySLink::SeedLinkStream::type().

{
  TRACE;
  _error=NoError;
  switch (_request) {
  case Streams:
    _xmlInfos.clear();
    _internals->slconn=LibSLink::sl_newslcd();
    sl_request_info(_internals->slconn, "STREAMS" );
    sl_setuniparams (_internals->slconn, 0, -1, 0);
    App::stream() << tr("Requesting list of streams...") << endl;
    break;
  case Stations:
    _xmlInfos.clear();
    _internals->slconn=LibSLink::sl_newslcd();
    LibSLink::sl_request_info(_internals->slconn, "STATIONS" );
    LibSLink::sl_setuniparams (_internals->slconn, 0, -1, 0);
    App::stream() << tr("Requesting list of stations...") << endl;
    break;
  case Data: {
      _internals->slconn=LibSLink::sl_newslcd();
      _mutex.lock();
      // Set fromTime to _fromTime if not all active signals are already initialized
      QDateTime fromTime;
      for(QMap<QByteArray,SeedLinkStream *>::iterator it=_listeningStreams.begin(); it!=_listeningStreams.end();it++) {
        SeedLinkStream& str=*it.value();
        if( !str.signal()) {
          fromTime=_fromTime;
          break;
        }
      }
      QMap<SeedLinkStation *,QList<SeedLinkStream *> > newStreams;
      for(QMap<QByteArray,SeedLinkStream *>::iterator it=_listeningStreams.begin(); it!=_listeningStreams.end();it++) {
        SeedLinkStream * str=it.value();
        SeedLinkStation * sta=str->station();
        QMap<SeedLinkStation *,QList<SeedLinkStream *> >::iterator its;
        its=newStreams.find(sta);
        if(its!=newStreams.end()) {
          its.value().append(str);
        } else {
          QList<SeedLinkStream *> list;
          list.append(str);
          newStreams.insert(sta, list);
        }
      }
      for(QMap<SeedLinkStation *,QList<SeedLinkStream *> >::iterator it=newStreams.begin(); it!=newStreams.end();it++) {
        SeedLinkStation * sta=it.key();
        QList<SeedLinkStream *>& list=it.value();
        QString selectors;
        for(QList<SeedLinkStream *>::iterator its=list.begin();its!=list.end();its++) {
          SeedLinkStream * str=*its;
          if(str->signal()) {
            QDateTime endTime=str->signal()->timeReference();
            endTime=endTime.addSecs((int) floor(str->signal()->endTime()) );
            if(!fromTime.isValid() || endTime<fromTime) fromTime=endTime;
          }
          selectors+=" "+str->location()+str->seedName()+"."+str->type();
        }
        App::stream() << tr("Requesting streams %1_%2:%3").arg(sta->network()).arg(sta->name()).arg(selectors) << endl;
        LibSLink::sl_addstream(_internals->slconn, sta->network().toAscii().data(),
                               sta->name().toAscii().data(),
                               selectors.toAscii().data(), -1, 0);
      }
      if(fromTime.isValid()) {
        _internals->slconn->begin_time=strdup(fromTime.toString("yyyy,MM,dd,hh,mm,ss").toAscii().data());
      }
      _mutex.unlock();
    }
    break;
  case Dns: {
      // Check if serverName is a numerical address or not
      QRegExp ipExp("[0-9]*\\.[0-9]*\\.[0-9]*\\.[0-9]*");
      if(ipExp.exactMatch(_serverName) ) {
        _serverAddress=_serverName+":"+QString::number(_serverPort).toAscii();
      } else {
        QHostInfo info=QHostInfo::fromName(_serverName);
        if(info.addresses().isEmpty()) {
          return;
        }
        _serverAddress=info.addresses().first().toString().toAscii()+":"+QString::number(_serverPort).toAscii();
        App::stream() << tr("Resolved %1:%2 into %3").arg(_serverName.data()).arg(_serverPort).arg(_serverAddress.data()) << endl;
      }
    }
    return;
  }

  _internals->slconn->sladdr=(char *) malloc(_serverAddress.length()+1);
  strcpy(_internals->slconn->sladdr, _serverAddress.data());
  _internals->slconn->resume=0;

  while(sl_collect(_internals->slconn, &_internals->slpack)!=0) {
    //App::stream() << tr("collect packet") << endl;
    packetReceived();
  }
  /* Make sure everything is shut down*/
  if(_internals->slconn->link!=-1) sl_disconnect (_internals->slconn);
  sl_freeslcd (_internals->slconn);
  _internals->slconn=0;
}
const SeedLinkServer& GeopsySLink::SeedLink::serverInfo ( ) const [inline]

Referenced by GeopsySLinkGui::SeedLinkLoader::selectStreams().

{return _serverInfo;}
QString GeopsySLink::SeedLink::serverName ( ) const [inline]

Referenced by GeopsySLinkGui::SeedLinkLoader::setServer().

{return _serverName;}
quint16 GeopsySLink::SeedLink::serverPort ( ) const [inline]

Referenced by GeopsySLinkGui::SeedLinkLoader::setServer().

{return _serverPort;}
void GeopsySLink::SeedLink::setBufferType ( SeedLinkStream::BufferType  bt) [inline]

Referenced by ConformProcess::ConformProcess(), GeopsySLinkGui::SeedLinkLoaderOptions::getParam(), ProcessUnit::ProcessUnit(), and GeopsySLinkGui::SeedLinkLoaderOptions::restore().

{_bufferType=bt;}
void GeopsySLink::SeedLink::setFromTime ( QDateTime  f) [inline]

Referenced by GeopsySLinkGui::SeedLinkLoaderOptions::getParam(), and GeopsySLinkGui::SeedLinkLoaderOptions::restore().

{_fromTime=f;}
void GeopsySLink::SeedLink::setMaximumDuration ( double  d) [inline]

Referenced by ConformProcess::ConformProcess(), GeopsySLinkGui::SeedLinkLoaderOptions::getParam(), GeopsySLinkGui::SeedLinkLoaderOptions::restore(), ProcessUnit::setArrayWindowLength(), and ProcessUnit::setHVWindowLength().

{_maximumDuration=d;}
void GeopsySLink::SeedLink::setServer ( QByteArray  address,
qint16  port 
)

References start(), stop(), and TRACE.

Referenced by ProcessUnit::setServer(), GeopsySLinkGui::SeedLinkLoader::setServer(), and ConformProcess::start().

{
  TRACE;
  stop();
  _serverName=address.trimmed();
  _serverPort=port;
  _request=Dns;
  start();
}
void GeopsySLink::SeedLink::start ( )

References stop(), and TRACE.

Referenced by setServer(), ConformProcess::start(), stations(), and streams().

{
  TRACE;
  if(isRunning()) stop();
  LibSLink::sl_loginit (0, log, NULL, log, NULL);
  QThread::start();
}
void GeopsySLink::SeedLink::stations ( )

References GeopsySLink::SeedLinkServer::clear(), start(), stop(), and TRACE.

{
  TRACE;
  stop();
  _request=Stations;
  _serverInfo.clear();
  _listeningStreams.clear();
  start();
}
void GeopsySLink::SeedLink::stop ( )

References GeopsySLink::SeedLinkPrivate::slconn, and TRACE.

Referenced by setServer(), start(), stations(), streams(), ProcessUnit::~ProcessUnit(), and GeopsySLinkGui::SeedLinkLoader::~SeedLinkLoader().

{
  TRACE;
  if(_internals->slconn) sl_terminate(_internals->slconn);
  wait();
  ASSERT(_internals->slconn==0);
}
void GeopsySLink::SeedLink::streams ( )

References GeopsySLink::SeedLinkServer::clear(), start(), stop(), and TRACE.

Referenced by ProcessUnit::setServer(), and GeopsySLinkGui::SeedLinkLoader::setServer().

{
  TRACE;
  stop();
  _request=Streams;
  _serverInfo.clear();
  _listeningStreams.clear();
  start();
}
SubSignalPool GeopsySLink::SeedLink::subPool ( ) const

References GeopsyCore::SubSignalPool::addSignal(), GeopsyCore::SubSignalPool::setName(), QGpCoreTools::tr(), and TRACE.

{
  TRACE;
  SubSignalPool s;
  for(QMap<QByteArray,SeedLinkStream *>::const_iterator it=_listeningStreams.begin(); it!=_listeningStreams.end();it++) {
    s.addSignal(it.value()->signal());
  }
  s.setName(tr("Active SeedLink signals"));
  return s;
}
The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Defines

Modified 2013-10-22

Valid CSS! Valid XHTML 1.0!