ALWAYS_INLINE
typename std::enable_if<
std::is_base_of<BaseMap, TMap>::value, Object>::type
BaseMap::php_zip(const Variant& iterable) const {
size_t sz;
ArrayIter iter = getArrayIterHelper(iterable, sz);
auto map = req::make<TMap>();
if (!m_size) {
return Object{std::move(map)};
}
map->reserve(std::min(sz, size_t(m_size)));
uint32_t used = posLimit();
for (uint32_t i = 0; i < used && iter; ++i) {
if (isTombstone(i)) continue;
const Elm& e = data()[i];
Variant v = iter.second();
auto pair = req::make<c_Pair>(c_Pair::NoInit{});
pair->initAdd(&e.data);
pair->initAdd(v);
TypedValue tv;
tv.m_data.pobj = pair.detach();
tv.m_type = KindOfObject;
if (e.hasIntKey()) {
map->setRaw(e.ikey, &tv);
} else {
assert(e.hasStrKey());
map->setRaw(e.skey, &tv);
}
++iter;
}
return Object{std::move(map)};
}
void PropertyFileConfiguration::parseLine(std::istream& istr)
{
static const int eof = std::char_traits<char>::eof();
int c = istr.get();
while (c != eof && Poco::Ascii::isSpace(c)) c = istr.get();
if (c != eof)
{
if (c == '#' || c == '!')
{
while (c != eof && c != '\n' && c != '\r') c = istr.get();
}
else
{
std::string key;
while (c != eof && c != '=' && c != ':' && c != '\r' && c != '\n') { key += (char) c; c = istr.get(); }
std::string value;
if (c == '=' || c == ':')
{
c = readChar(istr);
while (c != eof && c) { value += (char) c; c = readChar(istr); }
}
setRaw(trim(key), trim(value));
}
}
}
static int openTouchDev( char const *devName ){
int fd = -1 ;
if( !isSerial(devName) ){
fd = open(devName, O_RDONLY);
}
else {
printf( "Serial touch screen\n" );
char const *end = strchr( devName, ',' );
if( 0 == end )
end = devName + strlen(devName);
unsigned nameLen = end-devName ;
printf( "nameLen: %u, end %p\n", nameLen, end );
char deviceName[512];
if( nameLen < sizeof(deviceName) ){
memcpy( deviceName, devName, nameLen );
deviceName[nameLen] = '\0' ;
unsigned baud = 9600 ;
unsigned databits = 8 ;
char parity = 'N' ;
unsigned stop = 1 ;
if( '\0' != *end ){
end++ ;
baud = 0 ;
while( isdigit(*end) ){
baud *= 10 ;
baud += ( *end-'0' );
end++ ;
}
if( ',' == *end ){
end++ ;
databits = *end-'0' ;
end++ ;
if( ',' == *end ){
end++ ;
parity = *end++ ;
if( ',' == *end ){
stop = end[1] - '0';
}
}
}
}
fd = open( deviceName, O_RDWR );
if( 0 < fd ){
printf( "settings: %s,%u,%u,%c,%u\n", deviceName, baud, databits, parity, stop );
setBaud( fd, baud );
setRaw( fd );
setDataBits( fd, databits );
setStopBits( fd, stop );
setParity( fd, parity );
}
else
perror( deviceName );
}
else
fprintf( stderr, "Invalid touch device name\n" );
}
return fd ;
}
Data& Data::operator= (const Data& v){
if(&v != this){
setRaw(v.mData, v.offset(), v.stride(), v.type());
for(int i=0;i<maxDim();++i) mSizes[i]=v.mSizes[i];
}
return *this;
}
Expression::Expression(string &init)
{
if(!setRaw(const_cast<char *>(init.c_str())))
{
printf("Invalid initialization\n");
throw 42;
}
}
void BaseMap::addAllImpl(const Variant& iterable) {
if (iterable.isNull()) return;
VMRegGuard _;
decltype(cap()) oldCap = 0;
bool ok = IterateKV(
*iterable.asTypedValue(),
[&](ArrayData* adata) {
auto sz = adata->size();
if (!sz) return true;
if (!m_size) {
if (adata->isMixed()) {
replaceArray(adata);
updateIntLikeStrKeys();
return true;
}
} else {
oldCap = cap(); // assume minimal collisions
}
reserve(m_size + sz);
mutateAndBump();
return false;
},
[this](const TypedValue* key, const TypedValue* value) {
setRaw(tvAsCVarRef(key), tvAsCVarRef(value));
},
[this](ObjectData* coll) {
switch (coll->collectionType()) {
case CollectionType::Map:
case CollectionType::Set:
{
if (m_size) break;
auto hc = static_cast<HashCollection*>(coll);
replaceArray(hc->arrayData());
setIntLikeStrKeys(BaseMap::intLikeStrKeys(hc));
return true;
}
case CollectionType::Pair:
mutateAndBump();
break;
default:
break;
}
return false;
},
[this](const TypedValue* key, const TypedValue* value) {
set(tvAsCVarRef(key), tvAsCVarRef(value));
});
if (UNLIKELY(!ok)) {
throw_invalid_collection_parameter();
}
// ... and shrink back if that was incorrect
if (oldCap) shrinkIfCapacityTooHigh(oldCap);
}
ttyRaw* setTty(int fd, int setBaudRate) {
ttyRaw* new_tty;
new_tty = (ttyRaw*) malloc(sizeof(ttyRaw));
if (new_tty == NULL) {
perror("Malloc error");
return NULL;
}
new_tty->fd = fd;
if (setRaw(new_tty->fd, &new_tty->old_tio,
&new_tty->new_tio, setBaudRate) < 0) {
return NULL;
}
return new_tty;
}
ALWAYS_INLINE
typename std::enable_if<
std::is_base_of<BaseMap, TMap>::value, Object>::type
BaseMap::FromArray(const Class*, const Variant& arr) {
if (!arr.isArray()) {
SystemLib::throwInvalidArgumentExceptionObject(
"Parameter arr must be an array");
}
auto map = req::make<TMap>();
ArrayData* ad = arr.getArrayData();
map->reserve(ad->size());
for (ssize_t pos = ad->iter_begin(), limit = ad->iter_end(); pos != limit;
pos = ad->iter_advance(pos)) {
Variant k = ad->getKey(pos);
auto* tv = ad->getValueRef(pos).asCell();
if (k.isInteger()) {
map->setRaw(k.toInt64(), tv);
} else {
assert(k.isString());
map->setRaw(k.getStringData(), tv);
}
}
return Object(std::move(map));
}
void AbstractConfiguration::setRawWithEvent(const std::string& key, std::string value)
{
KeyValue kv(key, value);
if (_eventsEnabled)
{
propertyChanging(this, kv);
}
{
Mutex::ScopedLock lock(_mutex);
setRaw(key, value);
}
if (_eventsEnabled)
{
propertyChanged(this, kv);
}
}
serialSignal_t::serialSignal_t
( char const *devName,
serialSignalHandler_t handler )
: fd_( open( devName, O_RDWR ) )
, handler_( handler )
{
if( isOpen() ){
setRaw( fd_ );
if( 0 == serialSignal_ ){
serialSignal_ = nextRtSignal();
}
fcntl(fd_, F_SETOWN, getpid());
fcntl(fd_, F_SETSIG, serialSignal_ );
sigset_t blockThese ;
sigemptyset( &blockThese );
setSignalHandler( serialSignal_, blockThese, serialSignalHandler, this );
if( 0 != handler_ ){
int flags = flags = fcntl( fd_, F_GETFL, 0 );
flags |= FASYNC ;
fcntl( fd_, F_SETFL, flags | O_NONBLOCK );
}
}
}
ALWAYS_INLINE
typename std::enable_if<
std::is_base_of<BaseMap, TMap>::value, Object>::type
BaseMap::FromItems(const Class*, const Variant& iterable) {
if (iterable.isNull()) return Object{req::make<TMap>()};
VMRegGuard _;
size_t sz;
ArrayIter iter = getArrayIterHelper(iterable, sz);
auto target = req::make<TMap>();
target->reserve(sz);
for (; iter; ++iter) {
Variant v = iter.second();
TypedValue* tv = v.asCell();
if (UNLIKELY(tv->m_type != KindOfObject ||
tv->m_data.pobj->getVMClass() != c_Pair::classof())) {
SystemLib::throwInvalidArgumentExceptionObject(
"Parameter must be an instance of Iterable<Pair>");
}
auto pair = static_cast<c_Pair*>(tv->m_data.pobj);
target->setRaw(&pair->elm0, &pair->elm1);
}
return Object{std::move(target)};
}
void AbstractConfiguration::setString(const std::string& key, const std::string& value)
{
FastMutex::ScopedLock lock(_mutex);
setRaw(key, value);
}
Expression::Expression(char * const init)
{
setRaw(init);
}
int main( int argc, char const * const argv[] )
{
if( 1 < argc )
{
char const *const deviceName = argv[1];
int const fdSerial = open( deviceName, O_RDWR );
if( 0 <= fdSerial )
{
fcntl( fdSerial, F_SETFD, FD_CLOEXEC );
fcntl( fdSerial, F_SETFL, O_NONBLOCK );
printf( "device %s opened\n", deviceName );
struct termios oldSerialState;
setRaw( fdSerial, oldSerialState);
struct termios oldStdinState;
setRaw( fileno(stdin), oldStdinState );
showStatus(fdSerial);
toggleRTS(fdSerial);
signal( SIGINT, ctrlcHandler );
pollfd fds[2];
fds[0].fd = fdSerial ;
fds[0].events = POLLIN | POLLERR ;
fds[1].fd = fileno(stdin);
fds[1].events = POLLIN | POLLERR ;
while( !doExit )
{
int const numReady = ::poll( fds, 2, 1000 );
if( 0 < numReady )
{
for( unsigned i = 0 ; i < 2 ; i++ )
{
if( fds[i].revents & POLLIN )
{
char inBuf[80];
int numRead = read( fds[i].fd, inBuf, sizeof(inBuf) );
for( int j = 0 ; j < numRead ; j++ )
{
char const c = inBuf[j];
switch( tolower(c) )
{
case 'x' :
case '\x03' : doExit = 1 ; break ;
case 'r' : toggleRTS(fdSerial); break ;
case 's' : showStatus(fdSerial); break ;
case 'w' : waitModemChange(fdSerial); break ;
case '!' : {
for( int line = 0 ; line < 10 ; line++ )
write( fdSerial, spewOutput, sizeof(spewOutput)-1 );
};
default:
printf( "%d: %c\r\n", fds[i].fd, inBuf[j] );
}
}
}
}
}
}
tcsetattr( fdSerial, TCSANOW, &oldSerialState );
tcsetattr( fileno(stdin), TCSANOW, &oldStdinState );
close( fdSerial );
}
else
perror( deviceName );
}
else
fprintf( stderr, "Usage: rtsCTS /dev/ttyS0\n" );
return 0 ;
}
void AbstractConfiguration::setBool(const std::string& key, bool value)
{
FastMutex::ScopedLock lock(_mutex);
setRaw(key, value ? "true" : "false");
}
void Temperature::setDegreesFahrenheit(const double degrees_fahrenheit)
{
setRaw(asRaw(asDegreesCelsius(degrees_fahrenheit)));
}
void Temperature::setDegreesCelsius(const double degrees_celsius)
{
setRaw(asRaw(degrees_celsius));
}
void AbstractConfiguration::setDouble(const std::string& key, double value)
{
FastMutex::ScopedLock lock(_mutex);
setRaw(key, NumberFormatter::format(value));
}
int main(int argc, char const * const argv[])
{
if (2 >= argc) {
fprintf(stderr,
"Usage: %s device baud "
"[databits=8 [parity=N [stopbits=1]]]\n",
argv[0]);
return -1;
}
char const *const deviceName = argv[1];
int const fdSerial = open(deviceName, O_RDWR);
if (0 > fdSerial) {
perror(deviceName);
return -1;
}
fcntl(fdSerial, F_SETFD, FD_CLOEXEC);
fcntl(fdSerial, F_SETFL, O_NONBLOCK);
int baud = strtoul(argv[2], 0, 0);
int databits = ((3 < argc) && (7 == strtoul(argv[3], 0, 0)))
? 7
: 8 ;
char parity = (4 < argc)
? toupper(*argv[4])
: 'N' ;
unsigned stopBits = ((5 < argc) && ('2' == *argv[5]))
? 2
: 1 ;
printf("device %s opened: %u baud, %d bits, parity %c\n", deviceName, baud, databits, parity);
struct termios oldSerialState;
setRaw(fdSerial, baud, databits, parity, stopBits, oldSerialState);
struct termios oldStdinState;
tcgetattr(0,&oldStdinState);
/* set raw mode for keyboard input */
struct termios newState = oldStdinState;
newState.c_cc[VMIN] = 1;
newState.c_lflag &= ~(ICANON | ECHO); // set raw mode for input
newState.c_iflag &= ~(IXON | IXOFF | IXANY|INLCR|ICRNL|IUCLC); //no software flow control
newState.c_oflag &= ~OPOST; //raw output
tcsetattr(0, TCSANOW, &newState);
signal(SIGINT, ctrlcHandler);
pollfd fds[2];
fds[0].fd = fdSerial ;
fds[0].events = POLLIN | POLLERR ;
fds[1].fd = fileno(stdin);
fds[1].events = POLLIN | POLLERR ;
while (!doExit) {
::poll(fds, 2, 1000);
for (unsigned i = 0 ; i < 2 ; i++) {
if (fds[i].revents & POLLIN) {
char inBuf[80];
int numRead = read(fds[i].fd, inBuf, sizeof(inBuf));
if (0 < numRead) {
int fdout = i ? fdSerial : 1;
write(fdout,inBuf,numRead);
}
}
}
}
tcsetattr(fdSerial, TCSANOW, &oldSerialState);
tcsetattr(0, TCSANOW, &oldStdinState);
close(fdSerial);
return 0 ;
}
