C++ DeviceName类代码示例

/**
 * \brief Construct a camera from a camera description
 *
 * \param name		Name of the camera
 * \return 		Camera with that name
 */
CameraPtr	QhyCameraLocator::getCamera0(const DeviceName& name) {
	QhyName	qhyname(name);
	if (!qhyname.isCamera(name)) {
		std::string	msg = stringprintf("%s is not a Camera name",
			name.toString().c_str());
		debug(LOG_ERR, DEBUG_LOG, 0, "%s", msg.c_str());
		throw std::runtime_error(msg);
	}

	// scan the devices and get 
	std::vector<usb::DevicePtr>	d = context.devices();
	std::vector<usb::DevicePtr>::const_iterator	i;
	for (i = d.begin(); i != d.end(); i++) {
		usb::DevicePtr	dptr = *i;
		int	busnumber = dptr->getBusNumber();
		int	deviceaddress = dptr->getDeviceAddress();
		if ((busnumber == qhyname.busnumber()) &&
			(deviceaddress == qhyname.deviceaddress())) {
			dptr->open();
			return CameraPtr(new QhyCamera(dptr));
		}
	}

	// failure to construct the camera
	std::string	msg = stringprintf("cannot create camera from '%s'",
		name.toString().c_str());
	throw std::runtime_error(msg);
}

/**
 * \brief Name of the device
 *
 * For derived components, this only returns the device name of the
 * parent device, it is the client's responsibilty to retrieve the
 * correct subdevice of the parent device.
 */
DeviceName	InstrumentComponentDerived::devicename() {
	DeviceName	name = _instrument.devicename(_derivedfrom);
	if (type() != DeviceName::Ccd) {
		name.type(type());
		return name;
	} else {
		return DeviceName(name, type(), stringprintf("%d", unit()));
	}
}

bool	DeviceName::operator==(const DeviceName& other) const {
	if (type() != other.type()) {
		return false;
	}
	if (size() != other.size()) {
		return false;
	}
	return std::equal(begin(), end(), other.begin());
}

bool	DeviceName::operator<(const DeviceName& other) const {
	if (type() < other.type()) {
		return true;
	}
	if (type() == other.type()) {
		return lexicographical_compare(begin(), end(),
						other.begin(), other.end());
	}
	return false;
}

DeviceName	DeviceName::parent(const DeviceName::device_type& devicetype) const {
	DeviceName	result;
	const_iterator	i = begin();
	size_type	j = 1;
	while (j++ < size()) {
		result.push_back(*i);
		i++;
	}
	result.type(devicetype);
	return result;
}

/**
 * \brief add the names of all cooler to a name vector
 *
 * \param names		list of names to which cooler names should be added
 */
void	AsiCameraLocator::addCoolerNames(std::vector<std::string>& names) {
	debug(LOG_DEBUG, DEBUG_LOG, 0, "retrieving Cooler names");
	int	n = ASIGetNumOfConnectedCameras();
	for (int index = 0; index < n; index++) {
		std::vector<std::string>	it = imgtypes(index);
		std::vector<std::string>::const_iterator	i;
		for (i = it.begin(); i != it.end(); i++) {
			DeviceName	ccdname = asiCcdName(index, *i);
			names.push_back(ccdname.child(DeviceName::Cooler,
				"cooler"));
		}
	}
}

/**
 * \brief Get a CCD device for a camera
 */
CcdPtr	QhyCameraLocator::getCcd0(const DeviceName& name) {
	debug(LOG_DEBUG, DEBUG_LOG, 0, "get QHY ccd named: %s",
		name.toString().c_str());
	QhyName	qhyname(name);
	if (!qhyname.isCcd(name)) {
		std::string	msg = stringprintf("%s is not a CCD name",
			name.toString().c_str());
		debug(LOG_ERR, DEBUG_LOG, 0, "%s", msg.c_str());
		throw std::runtime_error(msg);
	}

	DeviceName	cameraname = qhyname.cameraname();
	debug(LOG_DEBUG, DEBUG_LOG, 0, "looking for CCD of camera %s",
		cameraname.toString().c_str());
	CameraPtr	camera = this->getCamera(cameraname);
	return camera->getCcd(0);
}

GuidePortPtr	GpioLocator::getGuidePort0(const DeviceName& name) {
    debug(LOG_DEBUG, DEBUG_LOG, 0, "get the gpio guideport '%s'",
          name.toString().c_str());

    GpioGuideport	*guideport = new GpioGuideport(name);

    return GuidePortPtr(guideport);
}

/**
 * \brief Get a guider port by name
 */
GuidePortPtr	QhyCameraLocator::getGuidePort0(const DeviceName& name) {
	QhyName	qhyname(name);
	if (!qhyname.isGuideport(name)) {
		std::string	msg = stringprintf("%s is not a Guideport name",
			name.toString().c_str());
		debug(LOG_ERR, DEBUG_LOG, 0, "%s", msg.c_str());
		throw std::runtime_error(msg);
	}
	DeviceName	cameraname = qhyname.cameraname();
	debug(LOG_DEBUG, DEBUG_LOG, 0, "looking for guider port of camera %s",
		cameraname.toString().c_str());
	CameraPtr	camera = this->getCamera(cameraname);
	if (!camera->hasGuidePort()) {
		debug(LOG_ERR, DEBUG_LOG, 0, "camera has no guider port");
		throw NotFound("camera does not have a guider port");
	}
	return GuidePortPtr();
}

DeviceName	InstrumentComponent::remoteName() const {
	// find out whether the name is local or uses the nice module
	bool	useNice = true;

	// if this is already a local name, used unchanged
	if (!useNice) {
		debug(LOG_DEBUG, DEBUG_LOG, 0, "using localized name %s",
			_deviceurl.c_str());
		return DeviceName(_deviceurl);
	}

	// this is a remote name, so construct a remote name
	device::nice::DeviceNicer	nicer(_servicename);
	DeviceName	result = nicer(_deviceurl);
	debug(LOG_DEBUG, DEBUG_LOG, 0, "localized name: %s",
		result.toString().c_str());
	return result;
}

/**
 * \brief Get a camera from an instrument
 */
CameraPtr	Instrument::camera() {
	if (!isLocal(DeviceName::Camera)) {
		throw std::runtime_error("not a local camera");
	}
	debug(LOG_DEBUG, DEBUG_LOG, 0, "retrieve camera for instrument '%s'",
		_name.c_str());
	Repository	repository;
	Devices	devices(repository);
	InstrumentComponentPtr	cameraptr = component(DeviceName::Camera);
	switch (cameraptr->component_type()) {
	case InstrumentComponent::direct:
	case InstrumentComponent::mapped: {
		DeviceName	name = cameraptr->devicename();
		debug(LOG_DEBUG, DEBUG_LOG, 0, "camera: %s", name.toString().c_str());
		return devices.getCamera(name);
		}
	case InstrumentComponent::derived:
		throw std::runtime_error("don't know how to derive camera");
	}
	throw std::runtime_error("unknown component type");
}

/**
 * \brief Get a guider port by name
 */
GuiderPortPtr	OthelloLocator::getGuiderPort0(const DeviceName& name) {
	debug(LOG_DEBUG, DEBUG_LOG, 0, "looking for device %s",
		name.toString().c_str());
	// extract the serial number from the name
	std::string	serial = name.unitname();
	debug(LOG_DEBUG, DEBUG_LOG, 0, "looking for device unit %s",
		serial.c_str());

	// find the device with this serial number
	std::vector<astro::usb::DevicePtr>	d = context.devices();
	std::vector<astro::usb::DevicePtr>::const_iterator	i;
	for (i = d.begin(); i != d.end(); i++) {
		astro::usb::DevicePtr	dptr = (*i);
		uint16_t	vendor = dptr->descriptor()->idVendor();
		if (vendor != OTHELLO_VENDOR_ID) {
			break;
		}
		debug(LOG_DEBUG, DEBUG_LOG, 0, "device vendor: %04x", vendor);
		bool	needsclosing = true;
		if (dptr->isOpen()) {
			needsclosing = false;
		} else {
			dptr->open();
		}
		std::string	devserial = dptr->descriptor()->iSerialNumber();
		debug(LOG_DEBUG, DEBUG_LOG, 0, "device serial: %s",
			devserial.c_str());
		if (devserial == serial) {
			debug(LOG_DEBUG, DEBUG_LOG, 0, "matching guider port");
			return GuiderPortPtr(new OthelloGuiderPort(dptr));
		}
		if (needsclosing) {
			dptr->close();
		}
	}
	debug(LOG_ERR, DEBUG_LOG, 0, "coult no find device %s",
		name.toString().c_str());
	throw std::runtime_error("device not found");
}

/**
 * \brief Construct a camera from a camera description
 *
 * \param name		Name of the camera
 * \return Camera with that name
 */
CameraPtr	SxCameraLocator::getCamera0(const DeviceName& name) {
	std::string	sname = name.unitname();
	debug(LOG_DEBUG, DEBUG_LOG, 0, "analyzing '%s'", sname.c_str());
	// parse the name string
	int	busnumber = 0, deviceaddress = 0;
	sxparse(sname, busnumber, deviceaddress);
	debug(LOG_DEBUG, DEBUG_LOG, 0,
		"looking for busnumber=%d, deviceaddress=%d",
		busnumber, deviceaddress);

	// find the device with this bus number and address
	std::vector<DevicePtr>	d = context.devices();
	std::vector<DevicePtr>::const_iterator	i;
	for (i = d.begin(); i != d.end(); i++) {
		DevicePtr	dptr = (*i);
		if ((dptr->getBusNumber() == busnumber) &&
			(dptr->getDeviceAddress() == deviceaddress)) {
			debug(LOG_DEBUG, DEBUG_LOG, 0, "found matching device");
			dptr->open();
			return CameraPtr(new SxCamera(dptr));
		}
	}
	throw SxError("cannot create a camera from a name");
}

void	DeviceDenicer::setup(const DeviceName& original) {
    debug(LOG_DEBUG, DEBUG_LOG, 0, "denice '%s'",
          original.toString().c_str());
    if (original.modulename() != "nice") {
        throw std::runtime_error("cannot denice device names for "
                                 "other modules");
    }
    if (original.size() < 2) {
        throw std::runtime_error("bad nice device name: too short");
    }
    std::vector<std::string>	components;
    std::vector<std::string>::const_iterator	i = original.begin();
    i++; // skip the name nice
    _service = *i;
    i++; // skip the service name
    copy(i, original.end(), std::back_inserter(components));
    _devicename = std::shared_ptr<DeviceName>(new DeviceName(original.type(),
                  components));
    debug(LOG_DEBUG, DEBUG_LOG, 0, "deniced service name: %s",
          _devicename->toString().c_str());
}

/**
 * \brief Get an AO object
 */
AdaptiveOpticsPtr	SxCameraLocator::getAdaptiveOptics0(const DeviceName& name) {
	std::string	sname = URL::decode(name.unitname());
	debug(LOG_DEBUG, DEBUG_LOG, 0, "AO unit device name: %s", sname.c_str());
	return AdaptiveOpticsPtr(new SxAO(sname));
}