void
AddressTranslator::insert(
        const std::string &_address,
        const service_id_t _service, const instance_id_t _instance,
        major_version_t _major, minor_version_t _minor) {
    if (isValidService(_service) && isValidInstance(_instance)) {
        CommonAPI::Address address(_address);
        Address someipAddress(_service, _instance, _major, _minor);
#ifdef _WIN32
        EnterCriticalSection(&critSec);
#else
        std::lock_guard<std::mutex> itsLock(mutex_);
#endif
        auto fw = forwards_.find(address);
        auto bw = backwards_.find(someipAddress);
        if (fw == forwards_.end() && bw == backwards_.end()) {
            forwards_[address] = someipAddress;
            backwards_[someipAddress] = address;
            COMMONAPI_DEBUG(
                "Added address mapping: ", address, " <--> ", someipAddress);
        } else if(bw != backwards_.end() && bw->second != _address) {
            COMMONAPI_ERROR("Trying to overwrite existing SomeIP address which is "
                    "already mapped to a CommonAPI address: ",
                    someipAddress, " <--> ", _address);
        } else if(fw != forwards_.end() && fw->second != someipAddress) {
            COMMONAPI_ERROR("Trying to overwrite existing CommonAPI address which is "
                    "already mapped to a SomeIP address: ",
                    _address, " <--> ", someipAddress);
        }
#ifdef _WIN32
    LeaveCriticalSection(&critSec);
#endif
    }
}
void
DBusAddressTranslator::insert(
        const std::string &_address,
        const std::string &_service, const std::string &_path, const std::string &_interface, const bool _objPathStartWithDigits) {

    if (isValid(_service, '.',
            (_service.length() > 0 && _service[0] == ':'),
            (_service.length() > 0 && _service[0] == ':'),
            true)
      && isValid(_path, '/', true, _objPathStartWithDigits)
      && isValid(_interface, '.')) {
        CommonAPI::Address address(_address);
        DBusAddress dbusAddress(_service, _path, _interface);

        std::lock_guard<std::mutex> itsLock(mutex_);
        auto fw = forwards_.find(address);
        auto bw = backwards_.find(dbusAddress);
        if (fw == forwards_.end() && bw == backwards_.end()) {
            forwards_[address] = dbusAddress;
            backwards_[dbusAddress] = address;
            COMMONAPI_DEBUG(
                "Added address mapping: ", address, " <--> ", dbusAddress);
            if (!orgFreedesktopDBusPeerMapped_) {
                orgFreedesktopDBusPeerMapped_ = (_interface == "org.freedesktop.DBus.Peer");
                if (orgFreedesktopDBusPeerMapped_) {
                    COMMONAPI_DEBUG("org.freedesktop.DBus.Peer mapped");
                }
            }
        } else if(bw != backwards_.end() && bw->second != address) {
            COMMONAPI_ERROR("Trying to overwrite existing DBus address "
                    "which is already mapped to a CommonAPI address: ",
                    dbusAddress, " <--> ", _address);
        } else if(fw != forwards_.end() && fw->second != dbusAddress) {
            COMMONAPI_ERROR("Trying to overwrite existing CommonAPI address "
                    "which is already mapped to a DBus address: ",
                    _address, " <--> ", dbusAddress);
        }
    }
}