utilbase.cc

Go to the documentation of this file.

/*--------------------------------------------------------------------
 *
 * (C) Copyright Koninklijke Philips Electronics NV 2006. 
 * All rights reserved. This software is licensed under the terms of
 * version 2.1 of the GNU Lesser General Public License as published 
 * by the Free Software Foundation. For licensing and warranty
 * information, see the file COPYING in the main directory.
 *
 *------------------------------------------------------------------*/

#include <sys/types.h>
#include "utilbase.h"
#include "component.h"
#include "portbase.h"
#include "fifobase.h"
#include "processbase.h"
#include "networkbase.h"
#include <string.h>

// get fifo that is (indirectly) connected to this port
FifoBase* getFarFifo(const InPortBase* p)
{
  FifoBase* f = p->getSrcFifo();
  if (f)
    return f;
  else
    return getFarFifo((InPortBase*)p->getSrc());
}

FifoBase* getFarFifo(const OutPortBase* p)
{
  FifoBase* f = p->getDstFifo();
  if (f)
    return f;
  else
    return getFarFifo((OutPortBase*)p->getDst());
}

// get process port that reads/wites fifo f
InPortBase*  getFarInPort(const FifoBase* f)
{
  InPortBase* p = f->dstPort();
  while (p->nrDst())
    p = p->getDstPort();
  return p;
}

OutPortBase* getFarOutPort(const FifoBase* f)
{
  OutPortBase* p = f->srcPort();
  while (p->nrSrc())
    p = p->getSrcPort();
  return p;
}

void getFarInPorts(const FifoBase* f, InPortBases& ports)
{
  for(unsigned int i=0; i<f->nrDst(); i++)
  {
    InPortBase* p = f->dstPort(i);
    if (p->nrDst() == 0) 
      ports.push_back(p);
    else 
       getFarInPorts(p, ports);
  }
}

void getFarInPorts(const InPortBase* p, InPortBases& ports)
{
  for(unsigned int i=0; i<p->nrDst(); i++)
  {
    InPortBase* q = p->getDstPort(i);
    if (q->nrDst() == 0)
      ports.push_back(q);
    else
       getFarInPorts(q, ports);
  }
}

void getFarOutPorts(const FifoBase* f, OutPortBases& ports)
{
  OutPortBase* p = f->srcPort();
  if (p->nrSrc() == 0) 
    ports.push_back(p);
  else 
    getFarOutPorts(p->getSrcPort(), ports);
}


void getFarOutPorts(const OutPortBase* p, OutPortBases& ports)
{
  if (p->nrSrc() == 0)
    ports.push_back(p);
  else
    getFarOutPorts(p->getSrcPort(), ports);
}



InPortBase*  getFarInPort(const InPortBase* p);
OutPortBase* getFarOutPort(const OutPortBase* p);



InPortBase* findInPort(const Component* c, const char* name)
{
  for (unsigned int i=0; i<c->nrInPorts(); i++)
  {
    InPortBase* p = c->getInPort(i);
    if (strcmp(name, p->name()) == 0)
      return p;
  }
  return 0;
}

OutPortBase* findOutPort(const Component* c, const char* name)
{
  for (unsigned int i=0; i<c->nrOutPorts(); i++)
  {
    OutPortBase* p = c->getOutPort(i);
    if (strcmp(name, p->name()) == 0)
      return p;
  }
  return 0;
}


FifoBase* findFifo(const NetworkBase* n, const char* name)
{
  for (unsigned int i=0; i<n->nrFifos(); i++)
  {
    FifoBase* f = n->getFifo(i);
    if (strcmp(name, f->name()) == 0)
      return f;
  }
  return 0;
}

ProcessBase* findProcess(const NetworkBase* n, const char* name)
{
  for (unsigned int i=0; i<n->nrProcesses(); i++)
  {
    ProcessBase* p = n->getProcess(i);
    if (strcmp(name, p->name()) == 0)
      return p;
  }
  return 0;
}

NetworkBase* findNetwork(const NetworkBase* n, const char* name)
{
  for (unsigned int i=0; i<n->nrNetworks(); i++)
  {
    NetworkBase* w = n->getNetwork(i);
    if (strcmp(name, w->name()) == 0)
      return w;
  }
  return 0;
}


FifoBase*    recFindFifo   (const NetworkBase* n, const char* name);
FifoBase*    recFindInPort (const NetworkBase* n, const char* name);
FifoBase*    recFindOutPort(const NetworkBase* n, const char* name);
ProcessBase* recFindProcess(const NetworkBase* n, const char* name);
NetworkBase* recFindNetwork(const NetworkBase* n, const char* name);

---