void UtlXMLStream::writeAttribute(const std::string& sName, bool bValue) {
std::string sNormalizedName = normalizeAttributeName(sName);
getOutputStream() << " " << sNormalizedName.c_str() << "=\"";
if (bValue) getOutputStream() << "True";
else getOutputStream() << "False";
getOutputStream() << "\"";
}
void UtlXMLStream::writeHashtableEntry(const std::string& sKey, const std::vector<std::string>& listOfValues) {
getOutputStream() << _sIndentation.c_str() << "<pair key=\"" << sKey.c_str() << "\" >" << std::endl;
_sIndentation += "\t";
for (std::vector<std::string>::const_iterator i = listOfValues.begin(); i != listOfValues.end(); i++) {
getOutputStream() << _sIndentation.c_str() << "<string value=\"" << i->c_str() << "\" >" << std::endl;
}
_sIndentation = _sIndentation.substr(1);
getOutputStream() << _sIndentation.c_str() << "</pair>" << std::endl;
}
void JConnection::sendOk(){
getOutputStream();
out->writeByte((jint)JTransportConfiguration::MSG_TYPE_OK);
if (isReusable()){
out->flush();
}
}
void IppURLConnection::setContent()
{
if (connected && __ippRequest) {
ostream &os = getOutputStream();
os << *__ippRequest;
}
}
void VoteProcessorUsingHash::printOut(const CandidateList& maxCandidates) {
std::ostream& out = getOutputStream();
for (auto& name : maxCandidates) {
out << name << std::endl;
}
}
void UtlXMLStream::writeAttribute(const std::string& sName, const UtlDate& myValue) {
std::string sNormalizedName = normalizeAttributeName(sName);
std::string sDate = myValue.getString();
if (!myValue.isNull()) {
getOutputStream() << " " << sNormalizedName.c_str() << "=\"" << sDate.c_str() << "\"";
}
}
void
CClientProxy1_1::keyRepeat(KeyID key, KeyModifierMask mask,
SInt32 count, KeyButton button)
{
LOG((CLOG_DEBUG1 "send key repeat to \"%s\" id=%d, mask=0x%04x, count=%d, button=0x%04x", getName().c_str(), key, mask, count, button));
CProtocolUtil::writef(getOutputStream(), kMsgDKeyRepeat, key, mask, count, button);
}
void Logger::startLog( LogLevel loglevel, const char * file, int line,
const char * pretty)
{
getOutputStream() << getFormattedDate() << ' ' <<
logLevelToStr(loglevel) << " (" <<
file << ':' << line << ") [" <<
pretty << "] ";
}
void eepromMemoryReadBlock(Eeprom* eeprom_, unsigned long index, unsigned int length, Buffer* buffer) {
// Find a better implementation
unsigned long i;
for (i = index; i < index + length; i++) {
char value = eeprom_->eepromReadChar(eeprom_, i);
append(getOutputStream(buffer), value);
}
}
void notifyInfraredDetectorDetection(int type) {
Buffer* buffer = getMechanicalBoard2I2CSlaveOutputBuffer();
OutputStream* outputStream = getOutputStream(buffer);
append(outputStream, NOTIFY_INFRARED_DETECTOR_DETECTION);
appendHex2(outputStream, type);
// Debug
OutputStream* debugOutputStream = getDebugOutputStreamLogger();
append(debugOutputStream, NOTIFY_INFRARED_DETECTOR_DETECTION);
appendHex2(debugOutputStream, type);
}
void Logger::startLog(LogLevel loglevel, const char * file, int line,
const char * pretty)
{
std::string fileStr(file);
auto lastSlash = fileStr.find_last_of('/');
getOutputStream() << getFormattedDate() << ' ' <<
logLevelToStr(loglevel) << " " <<
fileStr.substr(lastSlash+1) << ':' << line << " [" <<
pretty << "] ";
}
bool HttpServletResponse::sendHeader(void)
{
acl_assert(header_->is_request() == false);
string buf;
if (charset_[0] != 0)
buf.format("%s; charset=%s", content_type_, charset_);
else
buf.format("%s", content_type_);
header_->set_content_type(buf.c_str());
buf.clear();
header_->build_response(buf);
return getOutputStream().write(buf) == -1 ? false : true;
}
void initDriverToI2CSlaveAndDebugCompositeOutputStream(bool includeI2C) {
initCompositeOutputStream(&driverToI2CSlaveAndDebugCompositeOutputStream);
// UART / DEBUG
addOutputStream(&driverToI2CSlaveAndDebugCompositeOutputStream, getInfoOutputStreamLogger());
// I2C
if (includeI2C) {
StreamLink* i2cStreamLink = getI2cStreamLink();
Buffer* i2cOutputBuffer = i2cStreamLink->outputBuffer;
OutputStream* i2cOutputStream = getOutputStream(i2cOutputBuffer);
addOutputStream(&driverToI2CSlaveAndDebugCompositeOutputStream, i2cOutputStream);
}
}
UtlXMLStream::UtlXMLStream(const std::string& sFileName, const bool bModeRead) : _bOwnerOfFileStream(true), _pInputStream(NULL), _pOutputStream(NULL) {
if (!bModeRead) {
_pOutputStream = CodeWorker::openOutputFile(sFileName.c_str());
if (_pOutputStream == NULL) throw UtlException("unable to open file \"" + sFileName + "\" for writing");
getOutputStream() << "<?xml version=\"1.0\" ?>" << std::endl;
}
else {
_pInputStream = ScpStream::openSTLInputFile(sFileName.c_str());
if (_pInputStream == NULL) throw UtlException("unable to open file \"" + sFileName + "\" for reading");
std::string sLineVersion;
if ( ! readLine(getInputStream() , sLineVersion) ) {
throw UtlException("No version line in XML file: " + sFileName );
}
}
_sFileName=sFileName;
}
jbool JConnection::openConnection(){
if (!opened){
opened=true;
getOutputStream();
out->writeInt(JTransportConfiguration::MAGIC_NUMBER);
connections->getTransport()->getLocalEndPoint()->write(out);
out->flush();
if (isReusable()){
jint oldTimeout=socket->getSoTimeout();
if (connections==NULL){
socket->setSoTimeout(transport->getTransportConfiguration()->getPingTimeout()->get());
}else{
socket->setSoTimeout(connections->getTransport()->getTransportConfiguration()->getPingTimeout()->get());
}
jbool b=readOk();
socket->setSoTimeout(oldTimeout);
return b;
}
}
return true;
}
void UtlXMLStream::writeEndOfAssociation(const std::string& sOwnerClass, const std::string& sName) {
_sIndentation = _sIndentation.substr(1);
getOutputStream() << _sIndentation.c_str() << "</" << sOwnerClass.c_str() << "_" << sName.c_str() << ">" << std::endl;
}
void UtlXMLStream::writeObjectReference(const std::string& sTypeName, const std::string& /*sIDAttrName*/, const std::string& sIdentifier) {
getOutputStream() << _sIndentation.c_str() << "<reference type=\"" << sTypeName.c_str() << "\" ID=\"" << sIdentifier.c_str() << "\" />" << std::endl;
}
void JConnection::finishCall(){
getOutputStream();
out->flush();
}
void JConnection::startCall(){
getOutputStream();
out->writeByte((jint)JTransportConfiguration::MSG_TYPE_CALL);
}
void UtlXMLStream::writeTag(const std::string& sTag) {
getOutputStream() << _sIndentation.c_str() << "<" << sTag.c_str() << "/>" << std::endl;
}
void print(First first, Args...args)
{
getOutputStream() << first;
print(args...);
}
void UtlXMLStream::writeStartTag(const std::string& sTag) {
getOutputStream() << _sIndentation.c_str() << "<" << sTag.c_str() << ">" << std::endl;
_sIndentation += "\t";
}
bool handleStreamInstruction(Buffer* inputBuffer,
Buffer* outputBuffer,
OutputStream* outputStream,
filterCharFunction* inputFilterChar,
filterCharFunction* outputFilterChar) {
if (inputBuffer == NULL) {
writeError(DRIVER_STREAM_LISTENER_INPUT_BUFFER_NULL);
return false;
}
if (outputBuffer == NULL) {
writeError(DRIVER_STREAM_LISTENER_OUTPUT_BUFFER_NULL);
return false;
}
// Try to clear the buffer if needed ('z' char)
if (clearBufferIfNeeded(inputBuffer)) {
return false;
}
// We received data
int inputBufferCount = getBufferElementsCount(inputBuffer);
if (inputBufferCount > 0) {
if (filterFirstNextChar(inputBuffer, inputFilterChar)) {
return false;
}
// As there is clear of char filtering, we must reload the size of the buffer
int bufferSize = getBufferElementsCount(inputBuffer);
if (bufferSize < DEVICE_HEADER_LENGTH) {
return false;
}
// Get the header
unsigned char deviceHeader = bufferGetCharAtIndex(inputBuffer, DEVICE_HEADER_INDEX);
// Manage the dispatcher specifier (3 chars : Ex j01 before real command ...)
unsigned char specifyDispatcherLength = 0;
if (deviceHeader == DATA_DISPATCHER_DEVICE_HEADER) {
specifyDispatcherLength += DISPATCHER_COMMAND_AND_INDEX_HEADER_LENGTH;
}
// Check if enough data
if (bufferSize < specifyDispatcherLength + DEVICE_AND_COMMAND_HEADER_LENGTH) {
return false;
}
// Reload the deviceHeader to take the dispatcher specifier if any
deviceHeader = bufferGetCharAtIndex(inputBuffer, specifyDispatcherLength + DEVICE_HEADER_INDEX);
unsigned char commandHeader = bufferGetCharAtIndex(inputBuffer, specifyDispatcherLength + COMMAND_HEADER_INDEX);
// find the device corresponding to this header. It must at least be declared in local or in remote !
unsigned char dataSize = bufferSize - specifyDispatcherLength;
const Device* device = deviceDataDispatcherFindDevice(deviceHeader, commandHeader, dataSize, DEVICE_MODE_INPUT);
// if the device was not found
if (device == NULL) {
return false;
}
// At this moment, device Interface is found
DeviceInterface* deviceInterface = device->deviceInterface;
// We must send device specifyDispatcherLength + Header + commandHeader + data => + 2
int dataToTransferCount = deviceInterface->deviceGetInterface(commandHeader, DEVICE_MODE_INPUT, false) + specifyDispatcherLength + DEVICE_AND_COMMAND_HEADER_LENGTH;
if (bufferSize < dataToTransferCount) {
return false;
}
// We must receive ack + device header + command header + data => + 3
int dataToReceiveCount = deviceInterface->deviceGetInterface(commandHeader, DEVICE_MODE_OUTPUT, false) + ACK_LENGTH + DEVICE_AND_COMMAND_HEADER_LENGTH;
InputStream* bufferedInputStream = getInputStream(inputBuffer);
OutputStream* bufferedOutputStream = getOutputStream(outputBuffer);
TransmitMode transmitMode = device->transmitMode;
// we handle locally the request
if (specifyDispatcherLength == 0 && transmitMode == TRANSMIT_LOCAL) {
// We need the implementation for local mode
DeviceDescriptor* deviceDescriptor = device->descriptor;
if (deviceDescriptor == NULL) {
writeError(NO_DEVICE_DESC_FOUND_FOR);
append(getErrorOutputStreamLogger(), deviceHeader);
append(getErrorOutputStreamLogger(), commandHeader);
return false;
}
// remove the first chars corresponding to the device header and command Header
bufferClearLastChars(inputBuffer, DEVICE_AND_COMMAND_HEADER_LENGTH);
// Call to the device
deviceDescriptor->deviceHandleRawData(commandHeader, bufferedInputStream, bufferedOutputStream);
} // we forward the request through Remote Operation with Dispatcher
else if (specifyDispatcherLength > 0 || transmitMode == TRANSMIT_I2C || transmitMode == TRANSMIT_UART || transmitMode == TRANSMIT_ZIGBEE) {
// Find dispatcher
DriverDataDispatcher* dispatcher = NULL;
if (specifyDispatcherLength > 0) {
bufferClearLastChars(inputBuffer, DEVICE_HEADER_LENGTH);
unsigned char dispatcherIndex = readHex2(bufferedInputStream);
dispatcher = getDriverDataDispatcherByIndex(dispatcherIndex);
if (dispatcher == NULL) {
writeError(NO_DISPATCHER_FOUND);
OutputStream* errorOutputStream = getErrorOutputStreamLogger();
appendStringAndDec(errorOutputStream, ", dispatcherIndex=", dispatcherIndex);
return false;
}
}
else {
TransmitMode transmitMode = device->transmitMode;
int address = device->address;
dispatcher = getDriverDataDispatcherByTransmitMode(transmitMode, address);
if (dispatcher == NULL) {
writeError(NO_DISPATCHER_FOUND);
OutputStream* errorOutputStream = getErrorOutputStreamLogger();
appendStringAndDec(errorOutputStream, ", transmitMode=", transmitMode);
append(errorOutputStream, '(');
appendString(errorOutputStream, getTransmitModeAsString(transmitMode));
append(errorOutputStream, ')');
appendStringAndDec(errorOutputStream, ", addr=", address);
return false;
}
}
// copy Driver buffer with remote Call
dispatcher->driverDataDispatcherTransmitData(dispatcher,
inputBuffer,
outputBuffer,
dataToTransferCount,
dataToReceiveCount
);
}
// In All Cases (Local / I2C / UART / Zigbee ...)
// Copy the data from bufferOutputStream to the outputStream
if (outputStream != NULL) {
copyInputToOutputStream(&(outputBuffer->inputStream), outputStream, outputFilterChar, dataToReceiveCount);
}
return true;
}
return false;
}
void UtlXMLStream::writeBeginningOfObject(const std::string& sTypeName) {
getOutputStream() << _sIndentation.c_str() << "<" << sTypeName.c_str();
_sIndentation += "\t";
}
void UtlXMLStream::writeBeginningOfAssociation(const std::string& sOwnerClass, const std::string& sName) {
getOutputStream() << _sIndentation.c_str() << "<" << sOwnerClass.c_str() << "_" << sName.c_str() << ">" << std::endl;
_sIndentation += "\t";
}
void Logger::endLog()
{
getOutputStream() << std::endl;
}
void print(First&& first, Args&&...args)
{
getOutputStream() << first;
print(std::forward<Args>(args)...);
}
void UtlXMLStream::writeEndTag(const std::string& sTag) {
_sIndentation = _sIndentation.substr(1);
getOutputStream() << _sIndentation.c_str() << "</" << sTag.c_str() << ">" << std::endl;
}
void
CClientProxy1_1::keyUp(KeyID key, KeyModifierMask mask, KeyButton button)
{
LOG((CLOG_DEBUG1 "send key up to \"%s\" id=%d, mask=0x%04x, button=0x%04x", getName().c_str(), key, mask, button));
CProtocolUtil::writef(getOutputStream(), kMsgDKeyUp, key, mask, button);
}
/**
* Function Name: SI2C1Interrupt
* Description : This is the ISR for I2C1 Slave interrupt.
*/
void __ISR(_I2C_1_VECTOR, ipl3) _SlaveI2CHandler(void)
{
// TODO : Find the right i2cBusConnection
I2cBusConnection* i2cBusConnection = NULL;
// last byte received is address and not data
char isData = I2C1STATbits.D_A;
char read = I2C1STATbits.R_W;
char isStart = I2C1STATbits.S;
char isSclRelease = I2C1CONbits.SCLREL;
char readBufferFull = I2C1STATbits.RBF;
// check for MASTER and Bus events and respond accordingly
if (IFS0bits.I2C1MIF == 1) {
mI2C1MClearIntFlag();
return;
}
if (IFS0bits.I2C1BIF == 1) {
mI2C1BClearIntFlag();
return;
}
StreamLink* i2cStreamLink = getI2cStreamLink();
// handle the incoming message
// Master want to write and send the address
if (isStart && !read && !isData && readBufferFull) {
// R/W bit = 0 --> indicates data transfer is input to slave
// D/A bit = 0 --> indicates last byte was address
// reset any state variables needed by a message sequence
// perform a dummy read of the address
portableSlaveReadI2C(i2cBusConnection);
// release the clock to restart I2C
portableSlaveClockRelease(i2cBusConnection);
}
// Master WRITE (InputStream)
else if (isStart && !read && isData && readBufferFull) {
// R/W bit = 0 --> indicates data transfer is input to slave
// D/A bit = 1 --> indicates last byte was data
int data = portableSlaveReadI2C(i2cBusConnection);
Buffer* i2cSlaveInputBuffer = i2cStreamLink->inputBuffer;
OutputStream* outputStream = getOutputStream(i2cSlaveInputBuffer);
// Read data from the Master
append(outputStream, data);
// for debug support
appendI2cDebugInputChar(data);
// release the clock to restart I2C
portableSlaveClockRelease(i2cBusConnection);
}
// Master send the address and want to read
else if (isStart && read && !isData) {
// R/W bit = 1 --> indicates data transfer is output from slave
// D/A bit = 0 --> indicates last byte was address
portableSlaveReadI2C(i2cBusConnection);
Buffer* i2cSlaveOutputBuffer = i2cStreamLink->outputBuffer;
// Get an inputStream to read the buffer to send to the master
InputStream* i2cInputStream = getInputStream(i2cSlaveOutputBuffer);
// There is available data
if (i2cInputStream->availableData(i2cInputStream)) {
char c = i2cInputStream->readChar(i2cInputStream);
// for debug support
appendI2cDebugOutputChar(c);
portableSlaveWriteI2C(i2cBusConnection, c);
} else {
portableSlaveWriteI2C(i2cBusConnection, I2C_SLAVE_NO_DATA_IN_READ_BUFFER);
}
}
// Master want to read
else if (isStart && read && isData && !isSclRelease) {
// R/W bit = 1 --> indicates data transfer is output from slave
// D/A bit = 1 --> indicates last byte was data
Buffer* i2cSlaveOutputBuffer = i2cStreamLink->outputBuffer;
// Get an inputStream to read the buffer to send to the master
InputStream* i2cInputStream = getInputStream(i2cSlaveOutputBuffer);
// There is available data
if (i2cInputStream->availableData(i2cInputStream)) {
char c = i2cInputStream->readChar(i2cInputStream);
// for debug support
appendI2cDebugInputChar(c);
// we send it to the master
portableSlaveWriteI2C(i2cBusConnection, c);
} else {
// There is no data, we send it to the master
portableSlaveWriteI2C(i2cBusConnection, I2C_SLAVE_NO_DATA_IN_READ_BUFFER);
}
}
// finally clear the slave interrupt flag
mI2C1SClearIntFlag();
}
