     
     private override init() {
         super.init()
-        self.impl = PeripheralManagerImpl<PeripheralManager>(peripheral:self)
-        self.cbPeripheralManager = CBPeripheralManager(delegate:self, queue:self.impl.peripheralQueue)
+        self.cbPeripheralManager = CBPeripheralManager(delegate:self, queue:PeripheralQueue.queue)
     }
     
 }

    }
    
    // advertising
    public func startAdvertising(name:String, uuids:[CBUUID]?) -> Future<Void> {
        self.afterAdvertisingStartedPromise = Promise<Void>()
        var advertisementData : [NSObject:AnyObject] = [CBAdvertisementDataLocalNameKey:name]
        if let uuids = uuids {
            advertisementData[CBAdvertisementDataServiceUUIDsKey] = uuids
        }
        self.peripheral.startAdvertising(advertisementData)
        return self.afterAdvertisingStartedPromise.future
    }
    
    public func startAdvertising(name:String) -> Future<Void> {
        return self.startAdvertising(name, uuids:nil)
    }
    
    public func startAdvertising(region:BeaconRegion) -> Future<Void> {
        self.afterAdvertisingStartedPromise = Promise<Void>()
        self.peripheral.startAdvertising(region.peripheralDataWithMeasuredPower())
        return self.afterAdvertisingStartedPromise.future
    }
    
    public func stopAdvertising() -> Future<Void> {
        self.afterAdvertsingStoppedPromise = Promise<Void>()
        self.peripheral.stopAdvertising()
        dispatch_async(self.peripheralQueue, {self.lookForAdvertisingToStop()})
        return self.afterAdvertsingStoppedPromise.future
    }
    
    // services
    public func addService(service:Wrapper.WrappedService) -> Future<Void> {
        self.afterSeriviceAddPromise = Promise<Void>()
        if !self.peripheral.isAdvertising {
            self.peripheral.addWrappedService(service)
            Logger.debug("PeripheralManagerImpl#addService:\(service.name), \(service.uuid)")
        } else {
            self.afterSeriviceAddPromise.failure(BCError.peripheralManagerAddServiceFailed)

        return self.afterSeriviceAddPromise.future
    }
    
    public func addServices(peripheral:Wrapper, services:[Wrapper.WrappedService]) -> Future<Void> {
        Logger.debug("PeripheralManagerImpl#addServices: service count \(services.count)")
        let promise = Promise<Void>()
        self.addService(peripheral, promise:promise, services:services)
        return promise.future
    }
    
    private func addService(peripheral:Wrapper, promise:Promise<Void>, services:[Wrapper.WrappedService]) {
        if services.count > 0 {
            let future = self.addService(peripheral, service:services[0])
            future.onSuccess {
                if services.count > 1 {
                    let servicesTail = Array(services[1...services.count-1])
                    Logger.debug("PeripheralManagerImpl#addServices: services remaining \(servicesTail.count)")
                    self.addService(peripheral, promise:promise, services:servicesTail)
                } else {
                    Logger.debug("PeripheralManagerImpl#addServices: completed")
                    promise.success()
                }
            }
            future.onFailure {(error) in
                let future = self.removeAllServices(peripheral)
                future.onSuccess {
                    Logger.debug("PeripheralManagerImpl#addServices: failed '\(error.localizedDescription)'")
                    promise.failure(error)
