 |
BeeeOn Gateway
v2020.3.1-2-g6f737dc
Platform to interconnect the IoT world
|
|
BeeeOn Gateway
v2020.3.1-2-g6f737dc
Platform to interconnect the IoT world
|
  BeeeOn | |
  ForPoco | |
   WithTrace | |
 BelkinWemoBulb | The class represents Belkin WeMo Led Light Bulb. It works with Belkin WeMo Link it uses his methods to turn off, turn on and the brightness control of bulb |
| BelkinWemoDevice | Abstract class representing generic BelkinWemo device |
| BelkinWemoDeviceManager | |
| BelkinWemoSeeker | Provides searching belkin wemo devices on network in own thread |
| BelkinWemoDimmer | The class represents Belkin WeMo Dimmer F7C059. Provides functions to control the switch. It means turn on, turn off, modify brigtness, get state |
| BelkinWemoLink | The class represents Belkin WeMo Link. Provides functions to control the bulbs. It means turn on, turn off, modify dim, get state of bulb |
| BelkinWemoStandaloneDevice | Abstract class representing generic BelkinWemo standalone device. The class implements sending messages to control the device |
| BelkinWemoSwitch | The class represents Belkin WeMo Switch F7C027fr. Provides functions to control the switch. It means turn on, turn off, get state |
| BeeWiDevice | Abstract class for BeeWi devices. Some BeeWi devices need to set the time to stop blinking. The method initLocalTime() is intended for it |
| BeeWiSmartClim | The class represents BeeWi temperature and humidity sensor. It allows to parse recieved data from the device. Its modules are temperature, humidity and battery level |
| BeeWiSmartDoor | The class represents BeeWi door sensor. It allows to parse recieved data from the device. Its modules are open/close and battery level |
| BeeWiSmartLite | The class represents BeeWi smart led light. It allows to gather and to control all its modules |
| BeeWiSmartMotion | The class represents BeeWi motion sensor. It allows to parse recieved data from the device. Its modules are motion and battery level |
| BeeWiSmartWatt | The class represents BeeWi smart switch. It allows to gather and to control all its modules |
| BLESmartDevice | Abstract class representing generic Bluetooth Low Energy smart device |
| BLESmartDeviceManager | The class implements the work with Bluetooth Low Energy devices. Allows us to process and execute the commands from server and gather data from the devices |
| BLESmartSeeker | Provides searching BLE devices on network in own thread |
| BluetoothAvailabilityManager | |
| BluetoothDevice | |
| HciClose | |
| HciAutoClose | |
| BluezHciInterface | |
| BluezHciInterfaceManager | |
| DBusHciConnection | The class represents connection with Bluetooth Low energy device. It allows sending read/write requests |
| DBusHciInterface | The class realizes communication with BlueZ deamon using D-Bus. It allows to find new BLE and Bluetooth Classic devices and send read/write requests |
| Device | The class represents the Bluetooth Low Energy device and stores necessary data about device such as instance of device, handle of signal and timestamp of last rssi update. Also the class allows to store necessary data (signal handle, pointer to callback) when the device is watched |
| DBusHciInterfaceManager | |
| GlibPtr | The class is used to store the references to objects from the GLib library. It is also responsible for automatically freeing of memory |
| HciConnection | The interface class represents connection with BLE device |
| HciInfo | |
| HciInfoReporter | HciInfoReporter periodically collects and reports statistics information about HCI interfaces in the system. Reporting is done via the HciListener interface |
| HciInterface | |
| HciInterfaceManager | |
| HciListener | |
| HciUtil | |
| RevogiDevice | Abstract class for Revogi devices |
| RevogiRGBLight | The class represents generic Revogi RGB light. It allows to control the on/off, brightness and color module |
| RevogiSmartCandle | The class represents Revogi Delite-ED33 smart candle. It allows to control all its modules |
| RevogiSmartLite | The class represents Revogi Delite-1748 bulb. It allows to control all its modules |
| RevogiSmartPlug | The class represents Revogi Smart Meter Plug. It allows to control all its modules |
| TabuLumenSmartLite | The class represents Tabu Lumen TL 100S Smart Light. It allows to control all its modules |
| DeviceAcceptCommand | |
| DeviceSearchCommand | DeviceSearchCommand requests a device manager to start searching for a single device specified by either its: |
| DeviceSetValueCommand | |
| DeviceUnpairCommand | |
| DeviceUnpairResult | DeviceUnpairResult holds set of devices that have been unpaired. If the set is empty, no device have been unpaired but the operation was successful |
| GatewayListenCommand | |
| NewDeviceCommand | |
| ServerDeviceListCommand | |
| ServerDeviceListResult | |
| ServerLastValueCommand | |
| ServerLastValueResult | |
| ConradDevice | Abstract class representing generic Conrad device |
| ConradDeviceManager | The class implements the work with Conrad devices. Allows us to process and execute the commands from server and gather data from the devices. It communicates with the Conrad devices using FHEM server. To communicate with FHEM server the class using FHEMClient which communicates with the FHEM server over telnet |
| ConradEvent | |
| ConradListener | |
| FHEMClient | The class communicates with FHEM server. It allows to search HomeMatic devices, gather data from HomeMatic devices and send commands to change state of a device |
| FHEMDeviceInfo | The class stores a statistic information about device maintained by FHEM server. According to these information FHEMClient generates events |
| PowerMeterSwitch | The class represents a standalone device Conrad Power meter switch. It allows to communicate with the device via Conrad interface |
| RadiatorThermostat | The class represents a standalone device Conrad Radiator thermostat. It allows to communicate with the device via Conrad interface |
| WirelessShutterContact | The class represents a standalone device Conrad Wireless shutter contact. It allows to communicate with the device via Conrad interface |
| AbstractCollector | The class represents a collector of events occuring inside the Gateway. It implements all available listeners that can potentially provide some interesting events about the Gateway and the connected sensors |
| AbstractDistributor | |
| AbstractSeeker | AbstractSeeker represents an asynchronous process that seeks for new devices in a certain network. It is basically a thread that performs some technology-specific routines to discover new devices |
| Answer | |
| AnswerQueue | |
| AsyncCommandDispatcher | AsyncCommandDispatcher implements dispatching of commands via a ParallelExecutor instance |
| BasicDistributor | |
| Command | |
| CommandDispatcher | |
| CommandDispatcherListener | |
| CommandHandler | |
| CommandSender | |
| DeviceCache | DeviceCache manages pairing status devices which allows to choose different caching strategies like: in-memory cache, persistent cache, centralized cache, etc |
| DeviceManager | |
| DevicePoller | DevicePoller is a scheduler for PollableDevice instances. Any number of devices can be scheduled for regular polling of their state. Each device can be scheduled according to its refresh time and later cancelled from being polled |
| DeviceStatusFetcher | DeviceStatusFetcher is responsible for fetching pairing state of devices for the registered status handlers. The fetching is performed asynchronously and independently resulting in calling to the method DeviceStatusHandler::handleRemoteStatus() on the appropriate handlers |
| PrefixAnswer | To simplify Answer management, include the prefix of the connected ServerDeviceListCommand inside the answer |
| PrefixStatus | |
| DeviceStatusHandler | DeviceStatusHandler represents a class that can process status of a set of devices. This is useful when fetching pairing state from a remote server |
| Distributor | |
| DistributorListener | Interface to report events occuring in Distributor |
| DongleDeviceManager | |
| Exporter | |
| ExporterQueue | |
| FilesystemDeviceCache | FilesystemDeviceCache implements DeviceCache by creating and removing files inside a filesystem directory. Each paired device has a file named by its ID created. Devices are categorized by the ID prefix |
| GatewayInfo | Class for storing basic information about gateway |
| LoggingCollector | |
| MemoryDeviceCache | MemoryDeviceCache implements in-memory volatile DeviceCache |
| PollableDevice | PollableDevice is a device that is necessary to poll regularly for data. The polling can take some time to progress and the time should be significantly smaller than its refresh time |
| PollingKeeper | PollingKeeper takes care of devices that are being polled. It cancels all polled devices it manages upon request or destruction to avoid leaking unstopped polled devices |
| PrefixCommand | Ancestor for Commands that are related to a specific DevicePrefix only |
| QueuingDistributor | |
| QueuingExporter | Implements Exporter interface and provides SensorData prevents SensorData loss |
| Result | |
| StatusEnum | |
| TestingCenter | |
| ActionContext | |
| ActionRecord | |
| Credentials | |
| CredentialsStorage | |
| CredentialsTool | Standalone tool that can be used to manipulate the credentials storage directly. It parses the given command and performs the given action |
| FileCredentialsStorage | |
| PasswordCredentials | |
| PinCredentials | |
| InMemoryQueuingStrategy | Basic implementation of the QueuingStrategy interface |
| JournalQueuingStrategy | JournalQueuingStrategy implements persistent temporary storing of SensorData into a filesystem structure. It controls contents of a selected directory. The contents consists of buffer files and an index file (journal) |
| Entry | An instance of Entry represents a single record in the FileBuffer. Such record contains a single SensorData instance. Moreover, name of the source buffer and offset after the parsed data is provided |
| FileBuffer | Representation of a persistent file buffer that contains entries holding the stored SensorData |
| FileBufferStat | Helper struct with statistics collected during an inspection of a FileBuffer instance |
| MqttExporter | |
| NamedPipeExporter | |
| QueuingStrategy | |
| RecoverableJournalQueuingStrategy | RecoverableJournalQueuingStrategy works the same way as the JournalQueuingStrategy but it extends its behaviour with recovering features. The RecoverableJournalQueuingStrategy can recover partially broken and non-commited buffers |
| FitpDevice | |
| FitpDeviceManager | |
| AbstractHotplugMonitor | |
| HotplugEvent | |
| HotplugListener | |
| PipeHotplugMonitor | |
| UDevMonitor | |
| DPAIQHomeProtocol | |
| DPAMappedProtocol | Map the IQRFType-specific data to the BeeeOn-specific ones |
| DPAMessage | The class represents DPA message that can be sent/received from IQRF network |
| DPAProtocol | The class provides interface for obtaining of measured data, for detecting of supported modules that can be specific for general or some own protocol |
| ProductInfo | Vendor and product name for each paired device. It can be filled from IQRF repository or statically from code |
| DPARequest | DPA request contains a header: |
| DPAResponse | Each response contains a header with: |
| IQRFDevice | IQRFDevice represents information about a particular device from the IQRF network. Each IQRF device is identified by network address. Network address is a unique identifier in IQRF network. Each IQRF device has IQRF transceiver. The MID (Module ID) is globally unique. Each IQRF device can communicate using own or general protocol |
| IQRFDeviceManager | IQRFDeviceManager implements work with IQRF devices. IQRF Daemon (third party application) is used for communication with IQRF devices. For the communication with IQRF Daemon, IQRFConnector that allows to send/receive JSON message is used. Obtaining of measured data is implemented using LambdaTimerTask |
| IQRFEvent | |
| IQRFEventFirer | |
| IQRFJsonMessage | |
| IQRFJsonRequest | |
| IQRFJsonResponse | |
| DpaErrorEnum | |
| RawData | The structure corresponds to the composition of the field contained within the message data->raw https://apidocs.iqrf.org/iqrf-gateway-daemon/json/#iqrf/iqrfRaw-response-1-0-0.json |
| IQRFListener | |
| IQRFMqttConnector | IQRFMqttConnector provides sending and receiving messages. During data receiving, it is necessary to know identification of JSON message (GlobalID). The identification of message is used to bring sent and received message together |
| IQRFType | Represents one IQRF type |
| IQRFTypeMappingParser | IQRFTypeMappingParser can parse XML files defining mappings between IQRF types and BeeeOn ModuleTypes |
| IQRFUtil | |
| DPACoordBondedNodesRequest | DPA message that requires list of paired devices from coordinator |
| DPACoordBondNodeRequest | Request for node bonding with 10 s timeout (internal IQRF OS timeout) |
| DPACoordClearAllBondsRequest | |
| DPACoordDiscoveryRequest | |
| DPACoordRemoveNodeRequest | |
| DPANodeRemoveBondRequest | |
| DPABatchRequest | One batch request can contain several simple requests |
| DPAOSPeripheralInfoRequest | |
| DPAOSRestartRequest | |
| DPACoordBondedNodesResponse | DPA message that contains list of paired devices from coordinator. Up to 256 devices can be bonded |
| DPACoordBondNodeResponse | |
| DPACoordRemoveNodeResponse | |
| DPAOSPeripheralInfoResponse | |
| JablotronController | JablotronController provides access to the Turris Dongle that is connected via a serial port. The Turris Dongle must be probed to start an internal I/O thread that handles incoming messages |
| JablotronDeviceManager | JablotronDeviceManager utilizes the JablotronController to communicate with a Turris Dongle to receive reports (JablotronReport) and issue commands. It maintains pairing of individual gadgets (JablotronGadget) and provides 3 controllable (virtual) devices: PGX, PGY and Siren that can be associated with certain Jablotron devices (AC-88, JA-80L, etc.) |
| JablotronGadget | Representation of a real Jablotron Gadget registered inside the associated Turris Dongle |
| Info | Information about a Jablotron Gadget device type. Gadget types are distinguished by their address. A certain address range denotes a gadget device type |
| JablotronReport | Report with data coming from a sensor. Each report comes in format [AAAAAAAA] TYPE PAYLOAD. The AAAAAAAA is an address in decadic format. The TYPE represents type of the device. The PAYLOAD contains the actual report that depends on the TYPE |
| EventMetaData | |
| NemeaCollector | |
| AbstractHTTPScanner | The abstract class contains core of HTTP scanning of network. Derivated classes will have to implement methods to prepare HTTP request and if the response is from right device |
| GatewayMosquittoClient | |
| MosquittoClient | |
| MqttClient | |
| MqttMessage | |
| SOAPMessage | |
| UPnP | |
| VPTHTTPScanner | |
| PhilipsHueBridge | The class represents Philips Hue Bridge. Provides functions to control the bulbs. It means turn on, turn off, modify dim, get state of bulb |
| PhilipsHueBridgeInfo | |
| PhilipsHueBulb | Abstract class representing generic Philips Hue bulb |
| PhilipsHueBulbInfo | |
| PhilipsHueDeviceManager | The class implements the work with Philips Hue bulbs. Allows us to process and execute the commands from server. It means modify state of proper bulb |
| PhilipsHueSeeker | Provides searching philips devices on network in own thread |
| PhilipsHueDimmableBulb | The class represents dimmable Philips Hue bulb |
| PhilipsHueListener | |
| PressureSensorManager | |
| AbstractGWSConnector | Most GWSConnector implementations would solve the issue of sending prioritization and asynchronous queuing of outgoing messages. The AbstractGWSConnector aims on this issue |
| GWContextPoll | GWContextPoll stores contexts of sent messages. This is used for messages that expects the answer, so they can be matched. All supported operations are thread-safe |
| GWMessageContext | |
| GWTimedContext | |
| GWRequestContext | |
| GWResponseContext | |
| GWResponseWithAckContext | |
| GWSensorDataExportContext | |
| ContextPriorityComparator | |
| GWSCommandHandler | Handle requests to the remote server: |
| GWSCommandSender | Pass requests received from the remote server to the configured CommandDispatcher instance. The following messages are processed: |
| RequestAnswer | |
| GWSConnector | GWSConnector is an abstract class that defines an API for communication with a remote server. It keeps the connection alive and allows to send and receive messages |
| GWSConnectorImpl | Implements the communication via WebSockets with the remote server. Outgoing messages are prioritized based on the configured GWSPriorityAssigner instance. Incoming messages are broadcasted via the registered GWSListener instances. The GWSConnectorImpl takes care just for the lowest-level communication details: |
| GWServerConnector | The GWServerConnector allows the BeeeOn Gateway to communicate with the BeeeOn Server using WebSocket. It automatically connects and registers the gateway after start or connection loss |
| GWSFixedPriorityAssigner | Assigns a hard-wired priority to each message as follows: |
| GWSListener | GWSListener provides an interface for delivering of events and messages related to communication with the remote gateway server |
| Address | |
| GWSOptimisticExporter | GWSOptimisticExporter implements exporting via GWSConnector. It wraps the given SensorData instances and pass them to the GWSConnector::send(). It also keeps track of the connectivity to the remote server. Exporting is implemented optimistically, we assume no network failures. If the number of non-confirmed exports reached the limit exportNonConfirmed, no more exports occures until a confirmation comes |
| GWSOutputQueue | Queue for all outgoing messages. Must be initialized with Poco::Event reference, which is notified on item enqueue |
| GWSPriorityAssigner | Implementation of GWSPriorityAssigner interface provides a method for assigning of sending priority to GWMessage instances. The priorities are used for better control flow of output traffic |
| GWSQueuingExporter | GWSQueuingExporter implements stop-and-go exporting logic based on the QueuingExporter. The GWSQueuingExporter is to be explicitly registered as a GWSListener to a selected GWSConnector instance. The same GWSConnector instance should then be used for sending of messages |
| GWSResender | Sending of messages via a GWSConnector might not be reliable. Messages that have been sent can never reach the remote server. The GWSResender maintains the sent messages (where a reply is expected). When no response or ack is received on time, such message is sent again |
| ServerAnswer | ServerAnswer extends regular Answer with ID of corresponding received GWMessage, which was translated to dispatched Command. This ID is used to create GWMessage to inform server about execution status of this Command |
| SonoffDevice | Abstract class representing generic Sonoff device |
| SonoffDeviceManager | The class implements the work with Sonoff devices. Allows us to process and execute the commands from server and gather data from the devices |
| SonoffSC | The class represents Sonoff SC device. The class allows to process the messages from the Sonoff SC with the custom firmware (https://github.com/xbedna62/SonoffSC_firmware.git). Its modules are temperature, humidity, noise, dust and light |
| ChecksumSensorDataFormatter | ChecksumSensorDataFormatter is a wrapper around any SensorDataFormatter. Its job is to utilize the wrapped formatter for the actual serialization and to prepend a checksum at the beginning of the record |
| ChecksumSensorDataParser | ChecksumSensorDataParser parses data serialized by the equivalently configured ChecksumSensorDataFormatter. It first extracts the checksum at the beginning of the given string. Then the wrapped parser is used to parse the rest |
| ColorBrightness | The class stores color represent by red, green and blue component. It allows to count the brightness according to the biggest RGB component |
| CSVSensorDataFormatter | |
| Journal | Journal implements a simple journaling principle in filesystem. A Journal instance represents an append-only persistent list of records. Appending is an atomic operation. We either append the whole record or append nothing |
| Record | A single record in journal |
| JSONSensorDataFormatter | |
| JSONSensorDataParser | Provides a method to parse SensorData from a string containing JSONObject to a SensorData object |
| NullSensorDataFormatter | |
| SensorDataFormatter | |
| SensorDataParser | |
| TypeMappingParser | TypeMappingParser is an abstract class providing method parse() that reads a given definition file (inpus stream). The file contains mapping definitions between the target technology-specific data types and the BeeeOn data types (ModuleType) |
| XmlTypeMappingParser | XmlTypeMappingParser is an abstract specialization of the TypeMappingParser. It is used to parse an external input stream with type mapping definitions represented by a XML document |
| XmlTypeMappingParserHelper | Helper defining method for parsing an input stream as an XML input. The purpose is to extract information about type mapping. The class is stateful and represents a single loop over the parsed XML document |
| VirtualDevice | |
| VirtualDeviceManager | |
| VirtualModule | |
| VektivaDeviceManager | Vektiva device manager provides an easy way to manage devices that are compatible with implemented interface. In the current state it's Smarwi windows maintainer |
| VektivaSeeker | Provides searching of Vektiva devices on network via MQTT messages in an own thread |
| VektivaSmarwi | The class represents a standalone device Smarwi. It allows to communicate with the actual device via MQTT client and thus control it |
| VektivaSmarwiStatus | The class represents the status of the Smarwi device. The status information is obtained by MQTT client in the status message |
| VPTBoilerModuleTypeEnum | |
| VPTDevice | The class represents Thermona Regulator VPT LAN v1.0. It provides functions to control the VPT and to gather data from its sensors. Each VPT regulator consists of up to 4 zones and 1 boiler. This means one instance of VPTDevice takes care of 5 devices. Each subdevice has own DeviceID |
| VPTDeviceManager | The class implements the work with Regulators VPT LAN v1.0. Allows us to process and execute the commands from server. It means modify state of proper device |
| VPTSeeker | Provides searching vpt devices on network in own thread. Also takes care of thread where is the listen command performed |
| VPTValuesParser | |
| VPTZoneModuleTypeEnum | |
| AbstractZWaveNetwork | Abstract implementation of the ZWaveNetwork class. It provides a pre-implemented polling mechanism. It is assumed that exactly one thread calls the method pollEvent() periodically to read the events (using multiple threads might be an issue because we use Poco::Event) |
| AeotecZWaveMapperRegistry | |
| ClimaxZWaveMapperRegistry | |
| CompositeZWaveMapperRegistry | CompositeZWaveMapperRegistry allows to use multiple different ZWaveMapperRegistry instances by the ZWaveDeviceManager. Thus, it is possible to implement different device recognition strategies |
| FibaroZWaveMapperRegistry | |
| GenericZWaveMapperRegistry | Certain Z-Wave nodes can be mapped to the BeeeOn system generically. This allows to support any node type without knowing it in advance. The GenericZWaveMapperRegistry implements this approach |
| GenericMapper | |
| OZWCommand | OZWCommand handles OpenZWave command management. It allows to request a command to be executed and takes care of race conditions |
| OZWNetwork | OZWNetwork manages the Z-Wave network by using the OpenZWave library (OZW). Its purpose is to handle OZW notifications and initiate OZW commands if needed |
| OZWNode | OZWNode wraps the ZWaveNode to be able to hold specific data related to the OpenZWave library |
| OZWNotificationEvent | Low-level OpenZWave notification event. Because, the OpenZWave::Notification cannot be copied nor cloned, we have to represent it explicitly and copy all its contents |
| OZWPocoLoggerAdapter | OZWPocoLoggerAdapter adapts the the logging infrastructure of the OpenZWave library to the Poco::Logger. It converts the OpenZWave logging levels as follows: |
| SpecificZWaveMapperRegistry | SpecificZWaveMapperRegistry implements the method resolve() generically. The subclass of SpecificZWaveMapperRegistry should register a special instantiator creating the appropriate Mapper implementation based on the vendor and product IDs of Z-Wave nodes |
| MapperInstantiator | Instantiator of specific Mapper implementations |
| SimpleMapperInstantiator | Template implementation of MapperInstantiator creating MapperType instances having constructor specified as: MapperType(const ZWaveNode::Identity &, const std::string &) |
| Spec | Specification of a Z-Wave node to match |
| ST02L1ZWaveMapperRegistry | Support PIR sensor from different manufacturers that seems to be based on the same PCB marked as ST02L1(V1), 20140514 RoHS |
| ZWaveDeviceManager | ZWaveDeviceManager implements the logical layer on top of the ZWaveNetwork interface. It adapts the Z-Wave specifics to the BeeeOn system with the help of ZWaveMapperRegistry::Mapper |
| Device | High-level representation of a Z-Wave device. It enriches the ZWaveNode for information needed by the manager and the BeeeOn system. This means especially the Mapper instance |
| ZWaveDriverEvent | |
| ZWaveListener | |
| ZWaveMapperRegistry | ZWaveMapperRegistry is mostly intended to map Z-Wave specific data type hierarchy to BeeeOn ModuleType. Based on the ZWaveNode metadata, it constructs or looks up an appropriate Mapper object that knows how to interpret the ZWaveNode::Value instances to the rest of the BeeeOn system |
| Mapper | Map the ZWaveNode-specific data to the BeeeOn-specific ones. It is assumed that the ZWaveNode instance (or its Value) passed into the Mapper is the one used by ZWaveMapperRegistry::lookup() |
| ZWaveNetwork | ZWaveNetwork is an interface to a real Z-Wave network |
| PollEvent | Representation of events reported by the ZWaveNetwork implementation via the call pollEvent() |
| ZWaveNode | ZWaveNode represents information from the Z-Wave network about a particular node. Each Z-Wave node is identified by a home ID and node ID. The node ID is a locally unique identifier. The home ID is a globally unique (usually random generated) defined by the hardware controller |
| CommandClass | Command class representation of a Z-Wave value. We support only a subset of command classes that are relevant for using with the BeeeOn system |
| Identity | Identity of a Z-Wave node that can be used separately without any instance of the ZWaveNode class |
| Value | Value coming from the Z-Wave network. It holds some data (usually sensor data) and metadata to identify the value semantics |
| ZWaveNodeEvent | |
| ZWaveNodeInfo | |
| ZWaveSerialProber | ZWaveSerialProber detects whether the device connected to a serial port is a Z-Wave controller. We try to obtain its version (and report it). If the version cannot be obtained an exception is thrown |
| ZWaveTypeMappingParser | ZWaveTypeMappingParser can parse XML files defining mappings between Z-Wave command classes and BeeeOn ModuleTypes |
| InstanceInfo | |
| DependencyInjector | |
| DIApplicationConfigurationLoader | |
| DIDaemon | |
| UnhandledErrorHandler | |
| DIFactory | Implementation of DIFactory can manage and create instances by name and automatically (usually based on some configuration) inject dependencies into each instance |
| DIWCastRegistry | |
| DIWDuplicateException | |
| DIWCastException | |
| DIWWrongInputException | |
| DIWMethodHelper | |
| DIWTextSetter | |
| DIWStringSetter | |
| DIWCharSetter | |
| DIWTimeSetter | |
| DIWTimespanSetter | |
| DIWNumberSetter | |
| DIWIntSetter | |
| DIWDoubleSetter | |
| DIWBoolSetter | |
| DIWRefSetter | |
| DIWRawPtrSetter | |
| DIWSharedPtrSetter | |
| DIWListSetter | |
| DIWStringListSetter | |
| DIWMapSetter | |
| DIWStringStringMapSetter | |
| DIWCast | |
| DIWCastImpl | |
| DIWHook | |
| DIWHookHandler | |
| DIWrapper | |
| AbstractDIWrapper | |
| DIWrapperFactory | |
| DIXmlLoader | |
| GWAck | Represents an acknowledgement, that a response of the given id and status has been really delivered. It is intended to handle unreliable network connections |
| GWDeviceAcceptRequest | Represents a message sent by the server to the gateway, intended to inform gateway that the user accepted the discovered device. It means request to pair the device with the gateway |
| GWDeviceListRequest | Represents a message sent by the gateway to the server, intended to requests a list of paired devices with a specific prefix |
| GWDeviceListResponse | Represents a message sent byt the server to the gateway as a response to the GWDeviceListRequest |
| GWGatewayAccepted | Represents message sent by the server to the gateway after successful registration |
| GWGatewayRegister | Represents message sent by the gateway after connecting to the server. Message is intended to gateway registration on the server |
| GWLastValueRequest | Deprecated. Represents a message sent by the gateway to the server, intended to requests a last known value of a device module |
| GWLastValueResponse | Deprecated. Represents a message sent by the server to the gateway as a response to the GWLastValueRequest |
| GWListenRequest | Represents a message sent by the server to the gateway, intended to start 'listening mode' on the gateway. In this mode, gateway can discover new devices from the sensoric network |
| GWMessage | The GWMessage is abstract class representing messages (including their contents), that are being sent between Gateway and Server |
| GWMessageTypeEnum | |
| GWNewDeviceGroupRequest | Represents a message sent by the gateway to the server after discovering a device consisting of a group of subdevices in the sensoric network. Example of the device may be VPT regulator that consists of 4 zones and a boiler. Vendor name stored in message has to be same for all devices |
| GWNewDeviceRequest | Represents a message sent by the gateway to the server after discovering new device in the sensoric network |
| GWNoticeRequest | GWNoticeRequest allows a gateway to send a notice about something that happen. It can report progress information, error details, hints, etc. Each notice is defined by the following properties: |
| GWRequest | Abstract class representing a request message. The GWRequest can not be used alone, but it must be inherited by a specific request object |
| GWResponse | Represents a response to a request message (subclass of a GWRequest). The GWResponse can be used alone as a generic response or inherited by a more specific response object |
| GWResponseWithAck | Deprecated. Represents a response to a request message (subclass of a GWRequest), that requires acknowledgement (GWAck). In the future, just use a regular GWResponse and set ackRequired property to true |
| GWSearchRequest | This message is used to request searching for a device by criteria. This is a kind of a discovery process where it is known that a certain device has an exact identification. The search is always intended for 1 IoT technology |
| GWSensorDataConfirm | Represents message sent by the server to the gateway intended to confirm, that the server accepted exported sensor data represented by the GWSensorDataExport |
| GWSensorDataExport | Represents a message sent by the gateway to the server intended to export measured sensor data |
| GWSetValueRequest | Represents a message sent by the server to the gateway, intended to change state of an active module on the device |
| GWUnpairRequest | Represents a message sent by the server to the gateway, intended to unpair a paired device from the gateway |
| GWUnpairResponse | The unpair process might under certain circumstances unpair a different device then intended. The custom unpair response holds a list of IDs of devices unpaired by the unpair request. Depending on the server, it might be possible to use also generic GWResponse. But this class is better and should be preferred |
| DefaultClose | |
| AutoClose | |
| FdClose | |
| FdAutoClose | |
| ConsoleSessionImpl | |
| ConsoleSession | |
| Console | |
| ClosedConsoleSessionImpl | |
| FdStreamBuf | |
| FdStreamIOS | |
| FdInputStream | |
| FdOutputStream | |
| IOStats | IOStats represents common I/O statistics that are usually measured for performance monitoring |
| Data | |
| Printable | |
| IOSPrintable | |
| SafeWriter | SafeWriter is a helper that allows to perform file writes that are atomic. SafeWriter always rewrites a whole file. However, it either rewrites that file or it does nothing |
| SerialPort | |
| SimpleConsole | |
| StdConsole | |
| StreamConsoleSessionImpl | |
| StreamConsole | |
| TCPConsoleSessionImpl | |
| TCPConsole | |
| Locale | |
| LocaleImpl | |
| SystemLocaleImpl | |
| LocaleManager | |
| NoTranslator | |
| NoTranslatorFactory | |
| SystemLocaleManager | |
| Translator | |
| TranslatorFactory | |
| LoopRunner | |
| Stopper | Wrapper around StoppableLoop that allows to stop it from inside a thread |
| StopControl | StopControl implements the stop mechanism generically |
| Run | Helper class for managing a common stoppable loop situation: |
| StoppableLoop | |
| StoppableLoopAdapter | |
| StoppableRunnable | |
| Tool | The purpose of the class Tool is to provide a common set of features for loops that are to be used as command line tools. We can reuse the dependency-injection infrastructure to start a simple tool for some additional operation that is to be done out of the scoped of the main application |
| LogicalExpression | Representation of a logical expression in form: left operator right. The operator can be on of: |
| SimpleCalc | |
| CustomTypeID | |
| DeviceCriteria | DeviceCriteria holds a criteria for device searching. Device can be search by one of the following properties: |
| DeviceDescription | The class wraps information about a device's type. It describes its properties and provided sensor types |
| Builder | |
| DeviceID | |
| DevicePrefixEnum | |
| DevicePrefixNamesInitializer | |
| Entity | |
| GatewayID | |
| GlobalID | |
| Hash | |
| ModuleID | |
| ModuleType | |
| AttributeEnum | |
| TypeEnum | |
| Unit | Representation of physical units |
| UnitEnum | |
| OpModeEnum | OpModeEnum defines a mode of operation in the context of failure. Usually an operation (e.g. with a remote device) can fail. If it fails, we report an error. However, in certain situations, we might want to choose a different strategy of performing that operation (e.g. quickly send multiple request to increase probablity of success). Another possibility is to try again on failure until a timeout occurs |
| RefreshTime | RefreshTime represents time of refreshing values from sensors. E.g. sensors are polled periodically once per refresh time or sensors reports their values periodically once per refresh time |
| SensorData | |
| SensorValue | |
| SeverityEnum | Severity represents a level of importance of a message. Currently, only 3 levels are supported |
| SimpleID | |
| Hash | |
| TokenID | |
| HTTPEntireResponse | |
| HTTPUtil | |
| IPAddressRange | |
| IPAddressIterator | |
| MACAddress | |
| InfoProviderComparator | |
| InfoProvider | |
| NullInfoProvider | |
| XmlInfoProvider | |
| BetterRejectCertificateHandler | |
| SSLClient | |
| PrivateKeyPassphraseProvider | |
| SSLFacility | |
| SSLServer | |
| PEMMarkerStartToken | |
| PEMMarkerToken | |
| Base64Token | |
| X509Fingerprint | |
| About | |
| AbstractAsyncWork | AbstractAsyncWork provides a generic implementation of method result() and a supplementary method setResult(). The specialization for Poco::Void does not allow to set anything and throws exceptions. The result can be set only once |
| AnyAsyncWork | AnyAsyncWork represents an asynchronous work to be processed. Such work is defined only in terms of execution. It is started somehow (implementation specific) and can be joined or cancelled |
| ApplicationConfigurationLoader | |
| ArgsParser | |
| AsyncExecutor | |
| AsyncWork | AsyncWork is an interface allowing to wait until an asynchronous operation finishes. It is also possible to force-stop it by calling cancel() |
| AutoConfigurationExplorer | |
| BackOff | Back-off policy for retrying an operation |
| BackOffFactory | Factory for creation of preconfigured BackOff instances |
| Backtrace | |
| Base64 | |
| BlockingAsyncWork | BlockingAsyncWork is an adapter of non-asynchronous operations to the AsyncWork interface. It implements a time barrier that just waits until the underlying operation finishes |
| Cancellable | Any class that can be cancelled should inherit from this interface. This allows to maintain a set of cancellable objects together |
| CancellableSet | |
| Castable | |
| ClassInfo | |
| ConfigurationExplorer | |
| ConfigurationLoader | |
| ConfigurationSaver | |
| CryptoConfig | |
| CryptoParams | |
| DAMM | |
| DelayedAsyncWork | Implementation of the AsyncWork interface that executes a given function once after the the given delay unless it is cancelled |
| EnumHelper | |
| EnumNamesInitializer | |
| Enum | |
| EventSource | EventSource implements common logic for firing events to listeners |
| ExponentialBackOff | ExponentialBackOff implements the computation of delay when retrying an operation. It is usually used to lower load of a server |
| Config | |
| ExponentialBackOffFactory | |
| FailDetector | |
| FileLoader | |
| HashedLock | |
| HavingThreadPool | |
| Incomplete | |
| TimestampCompleteTest | |
| TimestampComplete | |
| Joiner | Joiner implements join() on a thread that can be called multiple times from different threads. The point is that the Poco::Thread::join() MUST NOT be called twice (unless its timeout exceeds) |
| JsonUtil | |
| LambdaTimerTask | |
| Loggable | |
| MultiException | MultiException is used to collect multiple exceptions thrown during some processing we do not want to interrupt. On every exception that occures during such processing, we add it into a prepared MultiException instance and after the processing finishes, we throw all the exceptions at once via the MultiException |
| NonAsyncExecutor | Implementation of AsyncExecutor that executes the tasks directly in the current thread. Thus, the execution is in fact not asynchronous. The purpose of the NonAsyncExecutor is to provide a way how to deal with delegation of asynchronous processing (that is already in a separate thread) to another AsyncExecutor-based system |
| Occasionally | |
| Once | |
| ParallelExecutor | Implementation of AsyncExecutor interface that invokes given procedures in parallel |
| PeriodicRunner | Executes some function periodacally based on the given interval |
| PosixSignal | The class implements working with POSIX signals |
| RandomBackOff | Back-off policy that generates random delays in range between the given min and max. The random generation can be explicitly seeded for deterministic results (otherwise, it is seeded from the system's entropy pool). The RandomBackOff generates the specified number of random delays or inifinite based on the property count |
| RandomBackOffFactory | RandomBackOffFactory creates a preconfigured instances of class RandomBackOff |
| NoLocator | |
| SAXElement | |
| SAXHelper | |
| DenyDTDHandler | |
| SecureXmlParser | |
| SequentialAsyncExecutor | |
| SingleInstanceChecker | SingleInstanceChecker can detect another equivalent running application instance. This might prevent running a same kind of application multiple-times |
| ThreadNamer | Name the current thread. The name can be assigned permanently or just until the destructor is called |
| ThreadRecursionProtector | ThreadRecursionProtector allows to prevent a recursive or repetitive execution of a code. The protection is implemented via methods enter() and leave(). To simplify using of the ThreadRecursionProtector, the ThreadRecursionProtector::Guard is to be used |
| Guard | Guard calls ThreadRecursionProtector::enter() from constructor and ThreadRecursionProtector::leave() from its destructor |
| ThreadWrapperAsyncWork | Adapter of Poco::Thread to AsyncWork interface. The Thread has no general way how to be stopped and thus the cancel() method is implemented as a blocking join() |
| TimeInterval | |
| TimespanParser | |
| UnsafePtr | |
| ValueGenerator | |
| LimitedGenerator | |
| RangeGenerator | |
| TimestampedGenerator | |
| TimeLimitedGenerator | |
| ConstGenerator | |
| SinGenerator | |
| RandomGenerator | |
| WaitCondition | WaitCondition works as a barrier that waits until some condition is met. When the condition is met and broadcasted, all waiting threads are woken up |
| Broadcaster | Broadcaster can be used to ensure that the broadcast is called even in cast when an unexpected exception is thrown. Broadcaster calls broadcast() from its destructor unless it has been called explicitly |
| Throwable | |
| Zip | The class provides an elegant way to iterate over 2 containers, which size can be different. Both const and non-const containers are supported. Zip::Iterator provides special functions to find out of which of the iterators did not come to an end. Dereferencing of Zip::Iterator returns std::pair formed by the references to values of containers. The iterators of containers can be also returned from Zip::Iterator |
| Iterator |
1.8.5