static char VehicleComponent_id[] = "$Header: /u/oreilly/rov/tmacs/RCS/VehicleComponent.cc,v 1.9 1998/12/18 21:20:11 oreilly Exp $";

/*
$Log: VehicleComponent.cc,v $
Revision 1.9  1998/12/18 21:20:11  oreilly
Add SemiMotor

Revision 1.8  1998/05/18 20:18:38  oreilly
*** empty log message ***

Revision 1.7  1998/02/23 16:14:03  oreilly
*** empty log message ***

Revision 1.6  1997/12/12 17:57:59  oreilly
*** empty log message ***

Revision 1.5  1997/10/03 09:34:27  oreilly
*** empty log message ***

Revision 1.4  97/09/10  08:53:54  08:53:54  oreilly (Thomas C. O'Reilly)
*** empty log message ***

Revision 1.3  97/05/06  16:32:35  16:32:35  oreilly (Thomas C. O'Reilly)
Added 3x5 micros

Revision 1.2  97/03/20  12:31:27  12:31:27  oreilly (Thomas C. O'Reilly)
..

Revision 1.1  96/10/28  09:12:48  09:12:48  oreilly (Thomas C. O'Reilly)
Initial revision

*/
#include <string.h>
#include <malloc.h>
#include "VehicleComponent.h"

const char *const VehicleComponent::vehicleBaseMnem = "VehicleBase";
const char *const VehicleComponent::busMnem = "PowerBus";
const char *const VehicleComponent::switchMnem = "Switch";
const char *const VehicleComponent::vicorSwitchMnem = "VicorSwitch";
const char *const VehicleComponent::motorSwitchMnem = "MotorSwitch";
const char *const VehicleComponent::isoIoSwitchMnem = "IsoIoSwitch";
const char *const VehicleComponent::switchStatusMnem = "SwitchStatus";
const char *const VehicleComponent::ibcMnem = "Ibc";
const char *const VehicleComponent::dconMnem = "Dcon";
const char *const VehicleComponent::motorMicroMnem = "MoogMotor";
const char *const VehicleComponent::semiMotorMicroMnem = "Motor";
const char *const VehicleComponent::cameraMicroMnem = "Camera";
const char *const VehicleComponent::panTiltMicroMnem = "PanTilt";
const char *const VehicleComponent::sio32MicroMnem = "Sio32";
const char *const VehicleComponent::telemMicroMnem = "Telemetry";
const char *const VehicleComponent::pduMicroMnem = "Pdu";
const char *const VehicleComponent::commRelaysMnem = "CommRelays";
const char *const VehicleComponent::toolsledMnem = "Toolsled";

VehicleComponent::VehicleComponent(const char *name) 
{
  if (name)
    _name = strdup(name);
  else
  {
    setError("Invalid name");
    return;
  }

  setParent(NULL);
}


VehicleComponent::~VehicleComponent()
{
  // Delete all children
  SListIter<VehicleComponent *>children(childList);
   
  VehicleComponent **child;
  children.reset();
  while (child = children.next())
    delete *child;
  
  if (_name) free(_name);
}


void VehicleComponent::addChild(VehicleComponent *child)
{
  child->setParent(this);
  childList.append(child);
}


void VehicleComponent::printChildren(int level)
{
  if (!childList.length())
    return;

  int i;
  
  for (i = 0; i < level - 1; i++)
    printf(" ");
    
  printf("{\n");

  VehicleComponent **child;

  SListIter<VehicleComponent *>children(childList);
  children.reset();
  while (child = children.next())
  {
    (*child)->print(level);
    (*child)->printChildren(level + 1);
  }
  for (i = 0; i < level - 1; i++)
    printf(" ");

  printf("}\n");
}


void VehicleComponent::print(int level)
{
  for (int i = 0; i < level; i++)
    printf(" ");
  
  printf("%s \"%s\"\n", className(), name());
}


MBool VehicleComponent::hasGrandChildren()
{
  VehicleComponent **child;

  SListIter<VehicleComponent *>children(childList);
  children.reset();
  while (child = children.next())
  {
    if ((*child)->childList.length())
      return TRUE;
  }

  return FALSE;
}


VehicleComponent::Type VehicleComponent::mnemonicType(const char *mnemonic)
{
  if (!strcmp(mnemonic, busMnem))
    return BusType;
  
  else if (!strcmp(mnemonic, switchMnem))
    return SwitchType;

  else if (!strcmp(mnemonic, motorSwitchMnem))
    return MotorSwitchType;

  else if (!strcmp(mnemonic, isoIoSwitchMnem))
    return IsoIoSwitchType;

  else if (!strcmp(mnemonic, switchStatusMnem))
    return SwitchStatusType;
  
  else if (!strcmp(mnemonic, vicorSwitchMnem))
    return VicorSwitchType;
  
  else if (!strcmp(mnemonic, ibcMnem))
    return IbcType;

  else if (!strcmp(mnemonic, dconMnem))
    return DconType;

  else if (!strcmp(mnemonic, motorMicroMnem))
    return MotorMicroType;

  else if (!strcmp(mnemonic, semiMotorMicroMnem))
    return SemiMotorMicroType;

  else if (!strcmp(mnemonic, cameraMicroMnem))
    return CameraMicroType;

  else if (!strcmp(mnemonic, panTiltMicroMnem))
    return PanTiltMicroType;

  else if (!strcmp(mnemonic, pduMicroMnem))
    return PduMicroType;

  else if (!strcmp(mnemonic, sio32MicroMnem))
    return Sio32MicroType;

  else if (!strcmp(mnemonic, telemMicroMnem))
    return TelemMicroType;
  
  else if (!strcmp(mnemonic, commRelaysMnem))
    return CommRelaysType;

  else if (!strcmp(mnemonic, toolsledMnem))
    return ToolsledType;
  
  else
    return UnknownType;
}


VehicleBase::VehicleBase(const char *name) :
  VehicleComponent(name)
{
}


VehicleBase::~VehicleBase()
{
}


Bus::Bus(const char *name) :
  VehicleComponent(name)
{
}


Bus::~Bus()
{
}

Switch::Switch(const char *name, const char *dmSwitchPrefix)
  : VehicleComponent(name)
{
  if (dmSwitchPrefix)
    _dmSwitchPrefix = strdup(dmSwitchPrefix);
  else
    _dmSwitchPrefix = NULL;
}


Switch::~Switch() 
{
  if (_dmSwitchPrefix) free(_dmSwitchPrefix);
}


MBool Switch::readOnly()
{
  return FALSE;
}


SwitchStatus::SwitchStatus(const char *name, const char *switchDmPrefix)
  : Switch(name, switchDmPrefix)
{
}


SwitchStatus::~SwitchStatus()
{
}


MBool SwitchStatus::readOnly()
{
  return TRUE;
}


IsoIoSwitch::IsoIoSwitch(const char *name, const char *dmSwitchPrefix)
  : Switch(name, dmSwitchPrefix)
{
}


IsoIoSwitch::~IsoIoSwitch() 
{
}


VicorSwitch::VicorSwitch(const char *name, const char *dmSwitchPrefix)
  : Switch(name, dmSwitchPrefix)
{
}


VicorSwitch::~VicorSwitch() 
{
}



MotorSwitch::MotorSwitch(const char *name, 
				   const char *dmSwitchPrefix,
				   const char *dmEnablePrefix)
  : Switch(name, dmSwitchPrefix)
{
  if (dmEnablePrefix)
    _dmEnablePrefix = strdup(dmEnablePrefix);
  else
  {
    setError("Invalid dmEnablePrefix");
    return;
  }
}


MotorSwitch::~MotorSwitch()
{
  if (_dmEnablePrefix) free(_dmEnablePrefix);
}


CommRelaysComponent::CommRelaysComponent(const char *name, 
					 const char *dmPrefix)
  : VehicleComponent(name)
{
  _dmPrefix = strdup(dmPrefix);
}


CommRelaysComponent::~CommRelaysComponent()
{
  free((void *)_dmPrefix);
}

const char *const ToolsledComponent::protoBenthicMnem = "protoBenthic";
const char *const ToolsledComponent::benthicMnem = "benthic";
const char *const ToolsledComponent::midwaterMnem = "midwater";
const char *const ToolsledComponent::geologyMnem = "geology";
const char *const ToolsledComponent::drillSledMnem = "drill";

ToolsledComponent::ToolsledComponent(const char *typeMnem)
  : VehicleComponent(typeMnem)
{
  if (!strcmp(typeMnem, protoBenthicMnem))
    _sledType = ProtoBenthic;
  else if (!strcmp(typeMnem, benthicMnem))
    _sledType = Benthic;
  else if (!strcmp(typeMnem, midwaterMnem))
    _sledType = Midwater;
  else if (!strcmp(typeMnem, geologyMnem))
    _sledType = Geology;
  else if (!strcmp(typeMnem, drillSledMnem))
    _sledType = DrillSled;
  else
  {
    char errorBuf[errorMsgSize];

    sprintf(errorBuf, "Invalid toolsled type \"%s\". Valid types are: %s",
	    typeMnem, validTypes());

    setError(errorBuf);
  }

  return;
}


ToolsledComponent::~ToolsledComponent()
{
}


const char *ToolsledComponent::validTypes()
{
  static char buf[256];

  sprintf(buf, "%s %s %s %s %s", 
	  protoBenthicMnem,
	  benthicMnem,
	  midwaterMnem,
	  geologyMnem,
	  drillSledMnem);
  
  return (const char *)buf;
}


const char *ToolsledComponent::typeMnem(ToolsledComponent::SledType type)
{
  switch (type)
  {
    case ProtoBenthic:
    return protoBenthicMnem;
    break;
    
    case Midwater:
    return midwaterMnem;
    break;
    
    case Benthic:
    return benthicMnem;
    break;
    
    case Geology:
    return geologyMnem;

    case DrillSled:
    return drillSledMnem;
  }

  return "Unknown!";
}



ToolsledComponent::SledType ToolsledComponent::mnemType(const char *mnem)
{
  if (!strcmp(mnem, protoBenthicMnem))
    return ProtoBenthic;
  else if (!strcmp(mnem, midwaterMnem))
    return Midwater;
  else if (!strcmp(mnem, benthicMnem))
    return Benthic;
  else if (!strcmp(mnem, geologyMnem))
    return Geology;
  else if (!strcmp(mnem, drillSledMnem))
    return DrillSled;
  else
    return Unknown;
}


ToolsledComponent::SledType ToolsledComponent::sledType()
{
  return _sledType;
}