         }
     }
     
-    public func removeService(service:Wrapper.WrappedService) -> Future<Void> {
+    public func removeService(peripheral:Wrapper, service:Wrapper.WrappedService) -> Future<Void> {
         let promise = Promise<Void>()
-        if !self.peripheral.isAdvertising {
+        if !peripheral.isAdvertising {
             Logger.debug("PeripheralManagerImpl#removeService: \(service.uuid.UUIDString)")
-            self.peripheral.removeWrappedService(service)
+            peripheral.removeWrappedService(service)
             promise.success()
         } else {
             promise.failure(BCError.peripheralManagerIsAdvertising)

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

    // advertising
    public func startAdvertising(name:String, uuids:[CBUUID]?) -> Future<Void> {
        self._name = name
        return self.impl.startAdvertising(self, name:name, uuids:uuids)
    }
    
    public func startAdvertising(name:String) -> Future<Void> {
        return self.impl.startAdvertising(self, name:name)
    }
    
    public func startAdvertising(region:BeaconRegion) -> Future<Void> {
        self._name = region.identifier
        return self.impl.startAdvertising(self, region:region)
    }
    
    public func stopAdvertising() -> Future<Void> {
        self._name = nil
        return self.impl.stopAdvertising(self)
    }
    
    // services
    public func addService(service:MutableService) -> Future<Void> {
        return self.impl.addService(self, service:service)
    }
    
    public func addServices(services:[MutableService]) -> Future<Void> {
        return self.impl.addServices(self, services:services)
    }

    public func removeService(service:MutableService) -> Future<Void> {
        return self.impl.removeService(self, service:service)
    }
    
    public func removeAllServices() -> Future<Void> {
        return self.impl.removeAllServices(self)
    }

    // CBPeripheralManagerDelegate
    public func peripheralManagerDidUpdateState(_:CBPeripheralManager!) {
        self.impl.peripheralManagerDidUpdateState(self)
    }
    
    public func peripheralManager(_:CBPeripheralManager!, willRestoreState dict: [NSObject : AnyObject]!) {
