Commit: 56d226ff8dd05b4a50b9e2c8d5a22b13b8c8249b - KCDtest (git)

main code repository.

Commit MetaInfo

• Revision: 56d226ff8dd05b4a50b9e2c8d5a22b13b8c8249b (tree)
• Time: 2018-03-18 10:40:33
• Author: masakih <masakih@user...>
• Commiter: masakih

Log Message

CoreDataのスレッドを使用するように修正

Change Summary

• modified: KCD/AirCorpsChangeNameCommand.swift
• modified: KCD/AirCorpsSupplyCommand.swift
• modified: KCD/AnchorageRepairManager.swift
• modified: KCD/ApplySuppliesCommand.swift
• modified: KCD/BasicMapper.swift
• modified: KCD/BookmarkListViewController.swift
• modified: KCD/BookmarkManager.swift
• modified: KCD/BroserWindowController.swift
• modified: KCD/CalculateDamageCommand.swift
• modified: KCD/ChangeHenseiCommand.swift
• modified: KCD/CoreDataManager.swift
• modified: KCD/CreateShipCommand.swift
• modified: KCD/DamageCalculator.swift
• modified: KCD/DestroyItem2Command.swift
• modified: KCD/DropShipHistoryCommand.swift
• modified: KCD/DummyShipCommand.swift
• modified: KCD/ExternalBrowserWindowController.swift
• modified: KCD/Fleet.swift
• modified: KCD/FleetManager.swift
• modified: KCD/GuardShelterCommand.swift
• modified: KCD/HistoryItemCleaner.swift
• modified: KCD/HistoryTableViewController.swift
• modified: KCD/JSONMapper.swift
• modified: KCD/KaisouLockCommand.swift
• modified: KCD/KenzoMarkCommand.swift
• modified: KCD/LocalDataStoreAccessor.swift
• modified: KCD/MapInfoCommand.swift
• modified: KCD/MapStartCommand.swift
• modified: KCD/MasterShipMapper.swift
• modified: KCD/MaterialMapper.swift
• modified: KCD/NyukyoSpeedChangeCommand.swift
• modified: KCD/NyukyoStartCommand.swift
• modified: KCD/QuestListCommand.swift
• modified: KCD/RealDestroyShipCommand.swift
• modified: KCD/RealPowerUpCommand.swift
• modified: KCD/RemodelSlotItemCommand.swift
• modified: KCD/ResetSortie.swift
• modified: KCD/ResourceHistoryManager.swift
• modified: KCD/SetActionCommand.swift
• modified: KCD/SetPlaneCommand.swift
• modified: KCD/ShipMapper.swift
• modified: KCD/ShipMasterDetailWindowController.swift
• modified: KCD/SlotItemMapper.swift
• modified: KCD/SlotResetCommand.swift
• modified: KCD/StoreCreateSlotItemHistoryCommand.swift
• modified: KCD/TSVSupport.swift
• modified: KCD/UpdateQuestListCommand.swift
• modified: KCD/UpdateSlotItemCommand.swift

Incremental Difference

--- a/KCD/AirCorpsChangeNameCommand.swift
+++ b/KCD/AirCorpsChangeNameCommand.swift
@@ -22,7 +22,8 @@ final class AirCorpsChangeNameCommand: JSONCommand {
         guard let name = parameter["api_name"].string else { return }
         
         let store = ServerDataStore.oneTimeEditor()
-        
-        store.airBase(area: areaId, base: rId)?.name = name
+        store.async {
+            store.airBase(area: areaId, base: rId)?.name = name
+        }
     }
 }

--- a/KCD/AirCorpsSupplyCommand.swift
+++ b/KCD/AirCorpsSupplyCommand.swift
@@ -18,37 +18,39 @@ final class AirCorpsSupplyCommand: JSONCommand {
     override func execute() {
         
         let store = ServerDataStore.oneTimeEditor()
-        
-        guard let areaId = parameter["api_area_id"].int else { return }
-        guard let rId = parameter["api_base_id"].int else { return }
-        guard let airBase = store.airBase(area: areaId, base: rId) else { return }
-        
-        let planeInfos = data["api_plane_info"]
-        let planes = airBase.planeInfo
-        
-        parameter["api_squadron_id"]
-            .integerArray
-            .enumerated()
-            .forEach {
-                
-                guard planes.count >= $0.element else { return }
-                guard planeInfos.count > $0.offset else { return }
-                guard let plane = planes[$0.element - 1] as? AirBasePlaneInfo else { return }
-                
-                let planeInfo = planeInfos[$0.offset]
-                
-                if let v = planeInfo["api_cond"].int { plane.cond = v }
-                if let v = planeInfo["api_slotid"].int { plane.slotid = v }
-                if let v = planeInfo["api_state"].int { plane.state = v }
-                if let v = planeInfo["api_count"].int { plane.count = v }
-                if let v = planeInfo["api_max_count"].int { plane.max_count = v }
+        store.async {
+            
+            guard let areaId = self.parameter["api_area_id"].int else { return }
+            guard let rId = self.parameter["api_base_id"].int else { return }
+            guard let airBase = store.airBase(area: areaId, base: rId) else { return }
+            
+            let planeInfos = self.data["api_plane_info"]
+            let planes = airBase.planeInfo
+            
+            self.parameter["api_squadron_id"]
+                .integerArray
+                .enumerated()
+                .forEach {
+                    
+                    guard planes.count >= $0.element else { return }
+                    guard planeInfos.count > $0.offset else { return }
+                    guard let plane = planes[$0.element - 1] as? AirBasePlaneInfo else { return }
+                    
+                    let planeInfo = planeInfos[$0.offset]
+                    
+                    if let v = planeInfo["api_cond"].int { plane.cond = v }
+                    if let v = planeInfo["api_slotid"].int { plane.slotid = v }
+                    if let v = planeInfo["api_state"].int { plane.state = v }
+                    if let v = planeInfo["api_count"].int { plane.count = v }
+                    if let v = planeInfo["api_max_count"].int { plane.max_count = v }
+            }
+            
+            if let v = self.data["api_distance"].int { airBase.distance = v }
+            
+            guard let material = store.material() else { return }
+            
+            if let v = self.data["api_after_bauxite"].int { material.bauxite = v }
+            if let v = self.data["api_after_fuel"].int { material.fuel = v }
         }
-        
-        if let v = data["api_distance"].int { airBase.distance = v }
-        
-        guard let material = store.material() else { return }
-        
-        if let v = data["api_after_bauxite"].int { material.bauxite = v }
-        if let v = data["api_after_fuel"].int { material.fuel = v }
     }
 }

--- a/KCD/AnchorageRepairManager.swift
+++ b/KCD/AnchorageRepairManager.swift
@@ -55,12 +55,13 @@ final class AnchorageRepairManager: NSObject {
         
         let ship = fleetManager?.fleets[fleetNumber - 1][position]
         
-        return ship?.master_ship.stype.id
+        return ServerDataStore.default.sync { ship?.master_ship.stype.id }
     }
     
     private func shipTypeId(shipId: Int) -> Int? {
         
-        return ServerDataStore.default.ship(by: shipId)?.master_ship.stype.id
+        let store = ServerDataStore.default
+        return store.sync { store.ship(by: shipId)?.master_ship.stype.id }
     }
     
     private func needsReset(info: HenseiDidChangeUserInfo) -> Bool {

--- a/KCD/ApplySuppliesCommand.swift
+++ b/KCD/ApplySuppliesCommand.swift
@@ -18,19 +18,22 @@ final class ApplySuppliesCommand: JSONCommand {
             .forEach { (_, json) in
                 
                 guard let i = json["api_id"].int else { return }
-                guard let ship = store.ship(by: i) else { return }
+                guard let ship = store.sync(execute: { store.ship(by: i) }) else { return }
                 guard let bull = json["api_bull"].int else { return }
                 guard let fuel = json["api_fuel"].int else { return }
                 guard let slots = json["api_onslot"].arrayObject as? [Int] else { return }
                 guard slots.count > 4 else { return }
                 
-                ship.bull = bull
-                ship.fuel = fuel
-                ship.onslot_0 = slots[0]
-                ship.onslot_1 = slots[1]
-                ship.onslot_2 = slots[2]
-                ship.onslot_3 = slots[3]
-                ship.onslot_4 = slots[4]
+                store.sync {
+                    
+                    ship.bull = bull
+                    ship.fuel = fuel
+                    ship.onslot_0 = slots[0]
+                    ship.onslot_1 = slots[1]
+                    ship.onslot_2 = slots[2]
+                    ship.onslot_3 = slots[3]
+                    ship.onslot_4 = slots[4]
+                }
         }
     }
 }

--- a/KCD/BasicMapper.swift
+++ b/KCD/BasicMapper.swift
@@ -35,11 +35,14 @@ final class BasicMapper: JSONMapper {
     
     func commit() {
         
-        let store = ServerDataStore.oneTimeEditor()
+        configuration.editorStore.async(execute: commintInContext)
+    }
+    private func commintInContext() {
         
-        guard let basic = store.basic() ?? store.createBasic() else {
-            
-            return Logger.shared.log("Can not Get Basic")
+        guard let store = configuration.editorStore as? ServerDataStore,
+            let basic = store.basic() ?? store.createBasic() else {
+                
+                return Logger.shared.log("Can not Get Basic")
         }
         
         registerElement(data, to: basic)

--- a/KCD/BookmarkListViewController.swift
+++ b/KCD/BookmarkListViewController.swift
@@ -149,20 +149,25 @@ extension BookmarkListViewController: NSTableViewDelegate, NSTableViewDataSource
         guard let items = info.draggingPasteboard().pasteboardItems else { return false }
         
         let store = BookmarkManager.shared.editorStore
-        items.enumerated().forEach {
+        store.sync {
+            items.enumerated().forEach {
+                
+                guard let data = $0.element.data(forType: .bookmarkItem) else { return }
+                guard let uri = NSKeyedUnarchiver.unarchiveObject(with: data) as? URL else { return }
+                guard let oID = self.managedObjectContext.persistentStoreCoordinator?.managedObjectID(forURIRepresentation: uri) else { return }
+                guard let bookmark = store.object(of: Bookmark.entity, with: oID) else { return }
+                
+                bookmark.order = targetOrder + $0.offset + 1
+            }
             
-            guard let data = $0.element.data(forType: .bookmarkItem) else { return }
-            guard let uri = NSKeyedUnarchiver.unarchiveObject(with: data) as? URL else { return }
-            guard let oID = managedObjectContext.persistentStoreCoordinator?.managedObjectID(forURIRepresentation: uri) else { return }
-            guard let bookmark = store.object(of: Bookmark.entity, with: oID) else { return }
+            store.save(errorHandler: store.presentOnMainThread)
             
-            bookmark.order = targetOrder + $0.offset + 1
+            self.bookmarkController.rearrangeObjects()
+            self.reorderingBoolmarks()
+            self.bookmarkController.rearrangeObjects()
         }
         
-        store.save(errorHandler: store.presentOnMainThread)
-        bookmarkController.rearrangeObjects()
-        reorderingBoolmarks()
-        bookmarkController.rearrangeObjects()
+        tableView.reloadData()
         
         return true
     }

--- a/KCD/BookmarkManager.swift
+++ b/KCD/BookmarkManager.swift
@@ -51,27 +51,36 @@ final class BookmarkManager: NSObject, NSMenuDelegate {
         return items
     }
     
-    func createNewBookmark() -> Bookmark? {
+    func createNewBookmark(configurator: @escaping (Bookmark) -> Bool) -> Bookmark? {
         
         guard let maxOrder = bookmarksController.value(forKeyPath: "[e-mail]") as? Int else {
             
             return Logger.shared.log("BookmarkManager: Can no convert max order to Int", value: nil)
         }
         
-        guard let new = editorStore.createBookmark() else {
+        let editorStore: BookmarkDataStore = BookmarkDataStore.oneTimeEditor()
+        
+        guard let new = editorStore.sync(execute: { editorStore.createBookmark() }) else {
             
             return Logger.shared.log("BookmarkManager: Can not insert BookMarkItem", value: nil)
         }
         
-        new.identifier = String(format: "B%@", arguments: [NSDate()])
-        new.order = maxOrder + 100
-        
-        DispatchQueue.main.asyncAfter(deadline: .now()) {
+        return editorStore.sync {
+            
+            new.identifier = String(format: "B%@", arguments: [NSDate()])
+            new.order = maxOrder + 100
             
-            self.editorStore.save(errorHandler: self.editorStore.presentOnMainThread)
+            if !configurator(new) {
+                
+                editorStore.delete(new)
+                
+                return nil
+            }
+            
+            editorStore.save(errorHandler: editorStore.presentOnMainThread)
+            
+            return new
         }
-        
-        return new
     }
     
     func menuNeedsUpdate(_ menu: NSMenu) {

--- a/KCD/BroserWindowController.swift
+++ b/KCD/BroserWindowController.swift
@@ -194,7 +194,7 @@ extension BroserWindowController {
     @IBAction func clearQuestList(_ sender: AnyObject?) {
         
         let store = ServerDataStore.oneTimeEditor()
-        store.quests().forEach(store.delete)
+        store.sync { store.quests().forEach(store.delete) }
     }
     
     // call from menu item

--- a/KCD/CalculateDamageCommand.swift
+++ b/KCD/CalculateDamageCommand.swift
@@ -111,54 +111,65 @@ extension CalculateDamageCommand {
         
         let store = TemporaryDataStore.oneTimeEditor()
         
-        store.damages().forEach(store.delete)
+        store.sync { store.damages().forEach(store.delete) }
     }
     
     func applyDamage() {
         
         let store = TemporaryDataStore.oneTimeEditor()
         
-        let totalDamages = store.sortedDamagesById()
+        let totalDamages = store.sync { store.sortedDamagesById() }
         
-        let aStore = ServerDataStore.oneTimeEditor()
+        let aStore = ServerDataStore.default
         
         Debug.excute(level: .debug) {
             
             print("-------")
             
-            totalDamages.forEach {
-                
-                guard let ship = aStore.ship(by: $0.shipID) else { return }
-                
-                if ship.nowhp != $0.hp {
+            store.sync {
+                totalDamages.forEach { damage in
+                    
+                    let shipId = damage.shipID
+                    guard let ship = aStore.sync(execute: { aStore.ship(by: shipId) }) else { return }
                     
-                    print("\(ship.name)(\(ship.id)),HP \(ship.nowhp) -> \($0.hp)")
+                    let damagedHp = damage.hp
+                    aStore.sync {
+                        if ship.nowhp != damagedHp {
+                            
+                            print("\(ship.name)(\(ship.id)),HP \(ship.nowhp) -> \(damagedHp)")
+                        }
+                    }
                 }
             }
             
-            
             print("------- End Battle")
         }
         
         // 第二艦隊単独出撃で正しくデータが反映されるように逆順にして計算
-        totalDamages.reversed().forEach {
-            
-            guard let ship = aStore.ship(by: $0.shipID) else { return }
-            
-            ship.nowhp = $0.hp
-            
-            if $0.useDamageControl { removeFirstDamageControl(of: ship) }
+        store.sync {
+            totalDamages.reversed().forEach { damage in
+                
+                let shipId = damage.shipID
+                guard let ship = aStore.sync(execute: { aStore.ship(by: shipId) }) else { return }
+                
+                let damagedHp = damage.hp
+                aStore.sync { ship.nowhp = damagedHp }
+                
+                if damage.useDamageControl { self.removeFirstDamageControl(of: shipId) }
+            }
         }
-        
     }
     
     func updateBattleCell() {
         
         let store = TemporaryDataStore.default
         
-        guard let battle = store.battle() else { return Logger.shared.log("Battle is invalid.") }
+        guard let battle = store.sync(execute: { store.battle() }) else {
+            
+            return Logger.shared.log("Battle is invalid.")
+        }
         
-        battle.battleCell = (battle.no == 0 ? nil : battle.no as NSNumber)
+        store.sync { battle.battleCell = (battle.no == 0 ? nil : battle.no as NSNumber) }
         
         Debug.excute(level: .debug) {
             
@@ -189,22 +200,45 @@ extension CalculateDamageCommand {
         }
     }
     
-    func removeFirstDamageControl(of ship: Ship) {
+    func removeFirstDamageControl(of shipId: Int) {
         
-        let store = ServerDataStore.default
-        
-        let (item, damageControl) = ship
-            .equippedItem
-            .lazy
-            .flatMap { $0 as? SlotItem }
-            .map { ($0, store.masterSlotItemID(by: $0.id)) }
-            .map { ($0.0, DamageControlID(rawValue: $0.1)) }
-            .filter { $0.1 != nil }
-            .first ?? (nil, nil)
-        
-        if let validDamageControl = damageControl {
+        let store = ServerDataStore.oneTimeEditor()
+        store.sync {
+            
+            guard let ship = store.ship(by: shipId) else { return }
+            
+            let (item, damageControl) = ship
+                .equippedItem
+                .lazy
+                .flatMap { $0 as? SlotItem }
+                .map { ($0, store.masterSlotItemID(by: $0.id)) }
+                .map { ($0.0, DamageControlID(rawValue: $0.1)) }
+                .filter { $0.1 != nil }
+                .first ?? (nil, nil)
             
-            switch validDamageControl {
+            if let validDamageControl = damageControl {
+                
+                switch validDamageControl {
+                case .damageControl: break
+                    
+                case .goddes:
+                    ship.fuel = ship.maxFuel
+                    ship.bull = ship.maxBull
+                }
+                
+                guard let equiped = ship.equippedItem.array as? [SlotItem] else { return }
+                
+                ship.equippedItem = NSOrderedSet(array: equiped.filter { $0 != item })
+                
+                return
+            }
+            
+            // check extra slot
+            let exItemId = store.sync { store.masterSlotItemID(by: ship.slot_ex) }
+            
+            guard let exType = DamageControlID(rawValue: exItemId) else { return }
+            
+            switch exType {
             case .damageControl: break
                 
             case .goddes:
@@ -212,26 +246,7 @@ extension CalculateDamageCommand {
                 ship.bull = ship.maxBull
             }
             
-            guard let equiped = ship.equippedItem.array as? [SlotItem] else { return }
-                
-            ship.equippedItem = NSOrderedSet(array: equiped.filter { $0 != item })
-            
-            return
+            ship.slot_ex = -1
         }
-        
-        // check extra slot
-        let exItemId = store.masterSlotItemID(by: ship.slot_ex)
-        
-        guard let exType = DamageControlID(rawValue: exItemId) else { return }
-        
-        switch exType {
-        case .damageControl: break
-            
-        case .goddes:
-            ship.fuel = ship.maxFuel
-            ship.bull = ship.maxBull
-        }
-        
-        ship.slot_ex = -1
     }
 }

--- a/KCD/ChangeHenseiCommand.swift
+++ b/KCD/ChangeHenseiCommand.swift
@@ -77,8 +77,8 @@ final class ChangeHenseiCommand: JSONCommand {
         
         if shipId == -1 {
             
-            guard let ship = removeShip(deckNumber: deckNumber, index: shipIndex) else { return }
-            notify(type: .remove, fleetNumber: deckNumber, position: shipIndex, shipID: ship.id)
+            guard let shipId = removeShip(deckNumber: deckNumber, index: shipIndex) else { return }
+            notify(type: .remove, fleetNumber: deckNumber, position: shipIndex, shipID: shipId)
             return
         }
         
@@ -92,22 +92,22 @@ final class ChangeHenseiCommand: JSONCommand {
         guard case 0..<Deck.maxShipCount = shipIndex else { return }
         
         let store = ServerDataStore.oneTimeEditor()
-        guard let deck = store.deck(by: deckNumber) else { return }
+        guard let deck = store.sync(execute: { store.deck(by: deckNumber) }) else { return }
         
         // すでに編成されているか？ どこに？
         let (shipDeckNumber, shipDeckIndex) = position(of: shipId)
         
         // 配置しようとする位置に今配置されている艦娘
-        let replaceShipId = deck[shipIndex]?.id
+        let replaceShipId = store.sync { deck[shipIndex]?.id }
         
         // 艦隊に配備
-        deck.setShip(id: shipId, for: shipIndex)
+        store.sync { deck.setShip(id: shipId, for: shipIndex) }
         
         // 入れ替え
         if shipDeckNumber != nil {
             
-            let shipDeck = store.deck(by: shipDeckNumber!)
-            shipDeck?.setShip(id: replaceShipId ?? -1, for: shipDeckIndex)
+            let shipDeck = store.sync { store.deck(by: shipDeckNumber!) }
+            store.sync { shipDeck?.setShip(id: replaceShipId ?? -1, for: shipDeckIndex) }
             shipDeck.map { packFleet(store: store, deck: $0) }
         }
         
@@ -132,40 +132,47 @@ final class ChangeHenseiCommand: JSONCommand {
     
     private func position(of shipId: Int) -> (deckNumber: Int?, shipId: Int) {
         
-        return ServerDataStore.default
-            .decksSortedById()
-            .lazy
-            .enumerated()
-            .map { (idx, deck) -> (Int, [Ship]) in (idx + 1, deck[0..<Deck.maxShipCount]) }
-            .filter { $0.1.contains { $0.id == shipId } }
-            .map { (deck, ships) in (deck, ships.index(where: { $0.id == shipId })!) }
-            .first ?? (nil, -1)
+        let store = ServerDataStore.default
+        return store.sync {
+            store
+                .decksSortedById()
+                .lazy
+                .enumerated()
+                .map { (idx, deck) -> (Int, [Ship]) in (idx + 1, deck[0..<Deck.maxShipCount]) }
+                .filter { $0.1.contains { $0.id == shipId } }
+                .map { (deck, ships) in (deck, ships.index(where: { $0.id == shipId })!) }
+                .first ?? (nil, -1)
+        }
     }
     
-    private func removeShip(deckNumber: Int, index: Int) -> Ship? {
+    private func removeShip(deckNumber: Int, index: Int) -> Int? {
         
         let store = ServerDataStore.oneTimeEditor()
         
-        guard let deck = store.deck(by: deckNumber) else { return Logger.shared.log("Deck not found", value: nil) }
+        guard let deck = store.sync(execute: { store.deck(by: deckNumber) }) else {
+            
+            return Logger.shared.log("Deck not found", value: nil)
+        }
         
-        let shipId = deck[index]?.id ?? -1
-        deck.setShip(id: -1, for: index)
+        let shipId = store.sync { deck[index]?.id ?? -1 }
+        store.sync { deck.setShip(id: -1, for: index) }
         
         packFleet(store: store, deck: deck)
         
-        return ServerDataStore.default.ship(by: shipId)
+        return shipId
     }
     
     private func excludeShipsWithoutFlagShip(deckNumber: Int) {
         
         let store = ServerDataStore.oneTimeEditor()
-        
-        guard let deck = store.deck(by: deckNumber) else {
+        store.sync {
+            guard let deck = store.deck(by: deckNumber) else {
+                
+                return Logger.shared.log("Deck not found")
+            }
             
-            return Logger.shared.log("Deck not found")
+            (1..<Deck.maxShipCount).forEach { deck.setShip(id: -1, for: $0) }
         }
-        
-        (1..<Deck.maxShipCount).forEach { deck.setShip(id: -1, for: $0) }
     }
     
     private func packFleet(store: ServerDataStore, deck: Deck) {
@@ -181,7 +188,7 @@ final class ChangeHenseiCommand: JSONCommand {
             set(newShips, at: index + 1, in: deck)
         }
         
-        set(deck[0..<Deck.maxShipCount], at: 0, in: deck)
+        store.sync { set(deck[0..<Deck.maxShipCount], at: 0, in: deck) }
     }
     
     private func notify(type: ChangeHenseiType,

--- a/KCD/CoreDataManager.swift
+++ b/KCD/CoreDataManager.swift
@@ -36,6 +36,10 @@ protocol CoreDataProvider {
 
 protocol CoreDataAccessor: CoreDataProvider {
     
+    func sync(execute: () -> Void)
+    func sync<T>(execute: () -> T) -> T
+    func async(execute: @escaping () -> Void)
+    
     func insertNewObject<T>(for entity: Entity<T>) -> T?
     func delete(_ object: NSManagedObject)
     func object<T>(of entity: Entity<T>, with objectId: NSManagedObjectID) -> T?
@@ -79,40 +83,50 @@ extension CoreDataProvider {
     
     func save() throws {
         
-        guard context.commitEditing() else {
-            
-            throw CoreDataError.couldNotSave("\(String(describing: type(of: self))) unable to commit editing before saveing")
-        }
-        
-        do {
+        var caughtError: Error?
+        context.performAndWait {
             
-            try context.save()
-            
-        } catch let error as NSError {
-            
-            throw CoreDataError.couldNotSave(error.localizedDescription)
-        }
-        
-        guard let parent = context.parent else { return }
-        
-        // save parent context
-        var catchedError: NSError? = nil
-        parent.performAndWait {
+            guard context.commitEditing() else {
+                
+                caughtError = CoreDataError.couldNotSave("\(String(describing: type(of: self))) unable to commit editing before saveing")
+                return
+            }
             
             do {
                 
-                try parent.save()
+                try context.save()
                 
             } catch let error as NSError {
                 
-                catchedError = error
+                caughtError = CoreDataError.couldNotSave(error.localizedDescription)
+                return
+            }
+            
+            guard let parent = context.parent else { return }
+            
+            // save parent context
+            var catchedError: NSError? = nil
+            parent.performAndWait {
+                
+                do {
+                    
+                    try parent.save()
+                    
+                } catch let error as NSError {
+                    
+                    catchedError = error
+                }
+            }
+            
+            if let error = catchedError {
+                
+                caughtError = CoreDataError.couldNotSave(error.localizedDescription)
             }
         }
         
-        if let error = catchedError {
-            
-            throw CoreDataError.couldNotSave(error.localizedDescription)
+        if let error = caughtError {
             
+            throw error
         }
     }
     
@@ -134,6 +148,25 @@ extension CoreDataProvider {
 
 extension CoreDataAccessor {
     
+    func sync(execute work: () -> Void) {
+        
+        self.context.performAndWait(work)
+    }
+    
+    func sync<T>(execute work: () -> T) -> T {
+        
+        var value: T!
+        sync {
+            value = work()
+        }
+        return value
+    }
+    
+    func async(execute work: @escaping () -> Void) {
+        
+        self.context.perform(work)
+    }
+    
     func insertNewObject<T>(for entity: Entity<T>) -> T? {
         
         return NSEntityDescription.insertNewObject(forEntityName: entity.name, into: context) as? T
@@ -155,11 +188,31 @@ extension CoreDataAccessor {
         req.sortDescriptors = sortDescriptors
         req.predicate = predicate
         
-        return try context.fetch(req)
+        var result: [T]?
+        var caughtError: Error?
+        sync {
+            do {
+                
+                result = try self.context.fetch(req)
+            } catch {
+                
+                caughtError = error
+            }
+        }
+        if let error = caughtError {
+            
+            throw error
+        }
+        
+        return result ?? []
     }
     
     func object(with objectId: NSManagedObjectID) -> NSManagedObject {
         
-        return context.object(with: objectId)
+        var result: NSManagedObject?
+        sync {
+            result = self.context.object(with: objectId)
+        }
+        return result!
     }
 }

--- a/KCD/CreateShipCommand.swift
+++ b/KCD/CreateShipCommand.swift
@@ -31,29 +31,53 @@ final class CreateShipCommand: JSONCommand {
         
         let store = ServerDataStore.default
         
-        guard let kenzoDock = store.kenzoDock(by: dockId),
-            let flagShip = store.deck(by: 1)?[0],
-            let basic = store.basic() else {
-                
-                return Logger.shared.log("CreateShipCommand: CoreData is wrong")
+        let storedInfos: KenzoMarkCommand.KenzoDockInfo? = store.sync {
+            
+            guard let kenzoDock = store.kenzoDock(by: dockId)  else {
+                    
+                    return nil
+            }
+            
+            return KenzoMarkCommand.KenzoDockInfo(dockId: kenzoDock.id,
+                                                  shipId: kenzoDock.created_ship_id,
+                                                  fuel: kenzoDock.item1,
+                                                  bull: kenzoDock.item2,
+                                                  steel: kenzoDock.item3,
+                                                  bauxite: kenzoDock.item4,
+                                                  kaihatusizai: kenzoDock.item5)
         }
         
-        let localStore = LocalDataStore.oneTimeEditor()
+        guard let infos = storedInfos else {
+            
+            return Logger.shared.log("Can not load KenzoDeck")
+        }
         
-        guard let newMark = localStore.kenzoMark(byDockId: dockId) ?? localStore.createKenzoMark() else {
+        guard let flagShip = store.sync(execute: { store.deck(by: 1)?[0] }) else {
             
-            return Logger.shared.log("Can not create KenzoMark")
+            return Logger.shared.log("Can not load deck")
+        }
+        guard let commanderLv = store.sync(execute: { store.basic()?.level }) else {
+            
+            return Logger.shared.log("Can not load basic")
         }
         
-        newMark.fuel = kenzoDock.item1
-        newMark.bull = kenzoDock.item2
-        newMark.steel = kenzoDock.item3
-        newMark.bauxite = kenzoDock.item4
-        newMark.kaihatusizai = kenzoDock.item5
-        newMark.created_ship_id = kenzoDock.created_ship_id
-        newMark.flagShipName = flagShip.name
-        newMark.flagShipLv = flagShip.lv
-        newMark.commanderLv = basic.level
-        newMark.kDockId = dockId
+        let localStore = LocalDataStore.oneTimeEditor()
+        localStore.sync {
+            guard let newMark = localStore.kenzoMark(byDockId: dockId) ?? localStore.createKenzoMark() else {
+                
+                return Logger.shared.log("Can not create KenzoMark")
+            }
+            
+            newMark.fuel = infos.fuel
+            newMark.bull = infos.bull
+            newMark.steel = infos.steel
+            newMark.bauxite = infos.bauxite
+            newMark.kaihatusizai = infos.kaihatusizai
+            newMark.created_ship_id = infos.shipId
+            newMark.flagShipName = store.sync { flagShip.name }
+            newMark.flagShipLv = store.sync { flagShip.lv }
+            newMark.commanderLv = commanderLv
+            newMark.kDockId = dockId
+        }
     }
 }

--- a/KCD/DamageCalculator.swift
+++ b/KCD/DamageCalculator.swift
@@ -34,48 +34,60 @@ extension DamageCalculator {
     
     func calculateBattle() {
         
-        calcKouku()
-        calcOpeningTaisen()
-        calcOpeningAttack()
-        calcHougeki1()
-        calcHougeki2()
-        calcHougeki3()
-        calcRaigeki()
+        store.sync {
+            
+            self.calcKouku()
+            self.calcOpeningTaisen()
+            self.calcOpeningAttack()
+            self.calcHougeki1()
+            self.calcHougeki2()
+            self.calcHougeki3()
+            self.calcRaigeki()
+        }
     }
     
     func calcCombinedBattleAir() {
         
-        calcKouku()
-        calcOpeningTaisen()
-        calcOpeningAttack()
-        calcHougeki1()
-        calcRaigeki()
-        calcHougeki2()
-        calcHougeki3()
+        store.sync {
+            
+            self.calcKouku()
+            self.calcOpeningTaisen()
+            self.calcOpeningAttack()
+            self.calcHougeki1()
+            self.calcRaigeki()
+            self.calcHougeki2()
+            self.calcHougeki3()
+        }
     }
     
     func calcEachBattleAir() {
         
-        calcKouku()
-        calcOpeningTaisen()
-        calcOpeningAttack()
-        calcHougeki1()
-        calcHougeki2()
-        calcRaigeki()
-        calcHougeki3()
+        store.sync {
+            
+            self.calcKouku()
+            self.calcOpeningTaisen()
+            self.calcOpeningAttack()
+            self.calcHougeki1()
+            self.calcHougeki2()
+            self.calcRaigeki()
+            self.calcHougeki3()
+        }
     }
     
     func calcEachNightToDay() {
         
-        calcNightHogeki1()
-        calcNightHogeki2()
-        calcKouku()
-        calcOpeningTaisen()
-        calcOpeningAttack()
-        calcHougeki1()
-        calcHougeki2()
-        calcRaigeki()
-        calcHougeki3()
+        store.sync {
+            
+            self.calcNightHogeki1()
+            self.calcNightHogeki2()
+            self.calcKouku()
+            self.calcOpeningTaisen()
+            self.calcOpeningAttack()
+            self.calcHougeki1()
+            self.calcHougeki2()
+            self.calcRaigeki()
+            self.calcHougeki3()
+        }
     }
     
     func calcEnemyCombinedBattle() {
@@ -86,7 +98,10 @@ extension DamageCalculator {
     
     func calcMidnight() {
         
-        calculateMidnightBattle()
+        store.sync {
+            
+            self.calculateMidnightBattle()
+        }
     }
 }
 
@@ -212,12 +227,14 @@ extension DamageCalculator {
         
         func setShip(_ ship: Ship, into damage: Damage) {
             
-            damage.shipID = ship.id
-            damage.hp = ship.nowhp
+            let sStore = ServerDataStore.default
+            
+            damage.shipID = sStore.sync { ship.id }
+            damage.hp = sStore.sync { ship.nowhp }
             
             Debug.excute(level: .debug) {
-                
-                print("add Damage entity of \(ship.name) at \(damage.id)")
+                let name = sStore.sync { ship.name }
+                print("add Damage entity of \(name) at \(damage.id)")
             }
         }
         
@@ -235,13 +252,15 @@ extension DamageCalculator {
         
         guard let battle = store.battle() else { return Logger.shared.log("Battle is invalid.") }
         
+        let sStore = ServerDataStore.default
         // 第一艦隊
-        let firstFleetShips = ServerDataStore.default.ships(byDeckId: battle.deckId)
+        let deckId = battle.deckId
+        let firstFleetShips = sStore.sync { sStore.ships(byDeckId: deckId) }
         
         // 第二艦隊
         if isCombinedBattle {
             
-            let secondFleetShips = ServerDataStore.default.ships(byDeckId: 2)
+            let secondFleetShips = sStore.sync { sStore.ships(byDeckId: 2) }
             buildDamages(first: firstFleetShips, second: secondFleetShips)
         } else {
             
@@ -298,9 +317,10 @@ extension DamageCalculator {
         
         Debug.excute(level: .debug) {
             
-            if receive != 0, let ship = ServerDataStore.default.ship(by: damage.shipID) {
+            let store = ServerDataStore.default
+            if receive != 0, let shipName = store.sync(execute: { store.ship(by: damage.shipID)?.name }) {
                 
-                print("\(ship.name) recieve Damage \(receive)")
+                print("\(shipName) recieve Damage \(receive)")
             }
         }
         
@@ -308,7 +328,8 @@ extension DamageCalculator {
         
         if damage.hp > 0 { return }
         
-        guard let ship = ServerDataStore.default.ship(by: damage.shipID) else { return }
+        let sStore = ServerDataStore.default
+        guard let ship = sStore.sync(execute: { sStore.ship(by: damage.shipID) }) else { return }
         
         damage.hp = damageControlIfPossible(ship: ship)
         damage.useDamageControl = (damage.hp != 0)
@@ -408,18 +429,34 @@ extension DamageCalculator {
     private func damageControlIfPossible(ship: Ship) -> Int {
         
         let store = ServerDataStore.default
-        
-        let damageControl = ship
-            .equippedItem
-            .lazy
-            .flatMap { $0 as? SlotItem }
-            .map { store.masterSlotItemID(by: $0.id) }
-            .flatMap { DamageControlID(rawValue: $0) }
-            .first
-        
-        if let validDamageControl = damageControl {
+        return store.sync {
+            let damageControl = ship
+                .equippedItem
+                .lazy
+                .flatMap { $0 as? SlotItem }
+                .map { store.masterSlotItemID(by: $0.id) }
+                .flatMap { DamageControlID(rawValue: $0) }
+                .first
+            
+            if let validDamageControl = damageControl {
+                
+                switch validDamageControl {
+                case .damageControl:
+                    Debug.print("Damage Control", level: .debug)
+                    return Int(Double(ship.maxhp) * 0.2)
+                    
+                case .goddes:
+                    Debug.print("Goddes", level: .debug)
+                    return ship.maxhp
+                }
+            }
+            
+            // check extra slot
+            let exItemId = store.masterSlotItemID(by: ship.slot_ex)
             
-            switch validDamageControl {
+            guard let exType = DamageControlID(rawValue: exItemId) else { return 0 }
+            
+            switch exType {
             case .damageControl:
                 Debug.print("Damage Control", level: .debug)
                 return Int(Double(ship.maxhp) * 0.2)
@@ -429,20 +466,5 @@ extension DamageCalculator {
                 return ship.maxhp
             }
         }
-        
-        // check extra slot
-        let exItemId = store.masterSlotItemID(by: ship.slot_ex)
-        
-        guard let exType = DamageControlID(rawValue: exItemId) else { return 0 }
-        
-        switch exType {
-        case .damageControl:
-            Debug.print("Damage Control", level: .debug)
-            return Int(Double(ship.maxhp) * 0.2)
-            
-        case .goddes:
-            Debug.print("Goddes", level: .debug)
-            return ship.maxhp
-        }
     }
 }

--- a/KCD/DestroyItem2Command.swift
+++ b/KCD/DestroyItem2Command.swift
@@ -19,9 +19,9 @@ final class DestroyItem2Command: JSONCommand {
         
         let store = ServerDataStore.oneTimeEditor()
         
-        store.slotItems(in: parameter["api_slotitem_ids"].integerArray).forEach(store.delete)
+        store.sync { store.slotItems(in: self.parameter["api_slotitem_ids"].integerArray).forEach(store.delete) }
         
-        guard let material = store.material() else {
+        guard let material = store.sync(execute: { store.material() }) else {
             
             return Logger.shared.log("Material is not found")
         }
@@ -31,9 +31,12 @@ final class DestroyItem2Command: JSONCommand {
             return Logger.shared.log("api_get_material is wrong")
         }
         
-        material.fuel += getMaterials[0]
-        material.bull += getMaterials[1]
-        material.steel += getMaterials[2]
-        material.bauxite += getMaterials[3]
+        store.sync {
+            
+            material.fuel += getMaterials[0]
+            material.bull += getMaterials[1]
+            material.steel += getMaterials[2]
+            material.bauxite += getMaterials[3]
+        }
     }
 }

--- a/KCD/DropShipHistoryCommand.swift
+++ b/KCD/DropShipHistoryCommand.swift
@@ -22,48 +22,54 @@ final class DropShipHistoryCommand: JSONCommand {
         guard let shipName = data["api_get_ship"]["api_ship_name"].string else { return }
         guard let winRank = data["api_win_rank"].string else { return }
         
-        guard let battle = TemporaryDataStore.default.battle() else {
+        let tempStore = TemporaryDataStore.default
+        guard let battle = tempStore.sync(execute: { tempStore.battle() }) else {
             
             return Logger.shared.log("Can not get Battle")
         }
         
-        let mapAreaId = battle.mapArea
+        let mapAreaId = tempStore.sync { battle.mapArea }
+        let mapInfoId = tempStore.sync { battle.mapInfo }
         
         let store = ServerDataStore.default
         
-        guard let mapInfo = store.mapInfo(area: mapAreaId, no: battle.mapInfo) else {
+        guard let mapInfoName = store.sync(execute: { store.mapInfo(area: mapAreaId, no: mapInfoId)?.name }) else {
             
             return Logger.shared.log("KCMasterMapInfo is not found")
         }
         
-        guard let mapArea = store.mapArea(by: mapAreaId) else {
+        guard let mapAreaName = store.sync(execute: { store.mapArea(by: mapAreaId)?.name }) else {
             
             return Logger.shared.log("KCMasterMapArea is not found")
         }
         
         
         let localStore = LocalDataStore.oneTimeEditor()
-        guard let new = localStore.createHiddenDropShipHistory() else {
+        localStore.sync {
             
-            return Logger.shared.log("Can not create HiddenDropShipHistory")
+            guard let new = localStore.createHiddenDropShipHistory() else {
+                
+                return Logger.shared.log("Can not create HiddenDropShipHistory")
+            }
+            
+            new.shipName = shipName
+            new.mapArea = "\(mapAreaId)"
+            new.mapAreaName = mapAreaName
+            new.mapInfo = tempStore.sync { battle.mapInfo }
+            new.mapInfoName = mapInfoName
+            new.mapCell = tempStore.sync { battle.no }
+            new.winRank = winRank
+            new.date = Date()
         }
-        
-        new.shipName = shipName
-        new.mapArea = "\(mapAreaId)"
-        new.mapAreaName = mapArea.name
-        new.mapInfo = battle.mapInfo
-        new.mapInfoName = mapInfo.name
-        new.mapCell = battle.no
-        new.winRank = winRank
-        new.date = Date()
     }
     
     private func storeToVisible() {
         
         let store = LocalDataStore.oneTimeEditor()
-        
-        let hidden = store.hiddenDropShipHistories()
-        _ = hidden.map(store.createDropShipHistory(from:))
-        hidden.forEach(store.delete)
+        store.sync {
+            let hidden = store.hiddenDropShipHistories()
+            _ = hidden.map(store.createDropShipHistory(from:))
+            hidden.forEach(store.delete)
+        }
     }
 }

--- a/KCD/DummyShipCommand.swift
+++ b/KCD/DummyShipCommand.swift
@@ -39,16 +39,14 @@ final class DummyShipCommand: JSONCommand {
         guard DummyShipCommand.needsEnterDummy else { return }
         
         let store = ServerDataStore.oneTimeEditor()
-        
-        store.createShip()?.id = -2
+        store.sync { store.createShip()?.id = -2 }
         DummyShipCommand.needsEnterDummy = false
     }
     
     private func removeDummy() {
         
         let store = ServerDataStore.oneTimeEditor()
-        
-        store.ships(by: -2).forEach(store.delete)
+        store.sync { store.ships(by: -2).forEach(store.delete) }
         DummyShipCommand.needsEnterDummy = false
     }
 }

--- a/KCD/ExternalBrowserWindowController.swift
+++ b/KCD/ExternalBrowserWindowController.swift
@@ -235,15 +235,18 @@ extension ExternalBrowserWindowController {
     @IBAction func addBookmark(_ sender: AnyObject?) {
         
         guard let window = window else { return }
-        guard let bookmark = BookmarkManager.shared.createNewBookmark() else { return }
-        
-        bookmark.name = window.title
-        bookmark.urlString = webView.mainFrameURL
-        bookmark.windowContentSize = windowContentSize
-        bookmark.contentVisibleRect = contentVisibleRect
-        bookmark.canResize = canResize
-        bookmark.canScroll = canScroll
-        bookmark.scrollDelay = 0.5
+        _ = BookmarkManager.shared.createNewBookmark { bookmark in
+            
+            bookmark.name = window.title
+            bookmark.urlString = self.webView.mainFrameURL
+            bookmark.windowContentSize = self.windowContentSize
+            bookmark.contentVisibleRect = self.contentVisibleRect
+            bookmark.canResize = self.canResize
+            bookmark.canScroll = self.canScroll
+            bookmark.scrollDelay = 0.5
+            
+            return true
+        }
     }
     
     @IBAction func showBookmark(_ sender: AnyObject?) {

--- a/KCD/Fleet.swift
+++ b/KCD/Fleet.swift
@@ -46,6 +46,8 @@ final class Fleet: NSObject {
     @objc dynamic private(set) var ships: [Ship] = []
     private var deck: Deck?
     
+    let store = ServerDataStore.default
+    
     init?(number: Int) {
         
         guard case 1...4 = number else {
@@ -58,7 +60,7 @@ final class Fleet: NSObject {
         
         super.init()
         
-        if let deck = ServerDataStore.default.deck(by: number) {
+        if let deck = store.sync(execute: { self.store.deck(by: number) }) {
             
             self.setupDeck(deck: deck)
             
@@ -68,7 +70,7 @@ final class Fleet: NSObject {
         ServerDataStore.default
             .future { _ -> Deck? in
                 
-                guard let deck = ServerDataStore.default.deck(by: number) else { return .none }
+                guard let deck = self.store.sync(execute: { self.store.deck(by: number) }) else { return .none }
                 
                 return deck
             }
@@ -82,7 +84,7 @@ final class Fleet: NSObject {
         }
     }
     
-    subscript(_ index: Int) -> Ship? { return deck?[index] }
+    subscript(_ index: Int) -> Ship? { return store.sync { self.deck?[index] } }
     
     private func setupDeck(deck: Deck) {
         
@@ -95,6 +97,6 @@ final class Fleet: NSObject {
     
     private func setupShips(deck: Deck) {
         
-        ships = deck[0...6]
+        ships = store.sync { deck[0...6] }
     }
 }

--- a/KCD/FleetManager.swift
+++ b/KCD/FleetManager.swift
@@ -64,16 +64,18 @@ final class FleetManager: NSObject {
     private func setNewFleetNumberToShip() {
         
         let store = ServerDataStore.oneTimeEditor()
-        
-        // clear all
-        store.shipsInFleet().forEach { $0.fleet = 0 as NSNumber }
-        
-        // set
-        fleets.enumerated().forEach { (index, fleet) in
+        store.sync {
             
-            fleet.ships.forEach {
+            // clear all
+            store.shipsInFleet().forEach { $0.fleet = 0 as NSNumber }
+            
+            // set
+            self.fleets.enumerated().forEach { index, fleet in
                 
-                store.ship(by: $0.id)?.fleet = (index + 1) as NSNumber
+                fleet.ships.forEach { ship in
+                    
+                    store.ship(by: ship.id)?.fleet = (index + 1) as NSNumber
+                }
             }
         }
     }

--- a/KCD/GuardShelterCommand.swift
+++ b/KCD/GuardShelterCommand.swift
@@ -42,19 +42,20 @@ final class GuardShelterCommand: JSONCommand {
     
     private func damagedShipId(damagedPos: Int) -> Int? {
         
-        let firstDeckId = TemporaryDataStore.default.battle()?.deckId ?? 1
+        let tempStore = TemporaryDataStore.default
+        let firstDeckId = tempStore.sync { tempStore.battle()?.deckId ?? 1 }
         
         let store = ServerDataStore.default
         
         switch firstDeckId {
         case 1:
             switch damagedPos {
-            case 1...6: return store.deck(by: 1)?.shipId(of: damagedPos - 1)
-            case 7...12: return store.deck(by: 2)?.shipId(of: damagedPos - 6 - 1)
+            case 1...6: return store.sync { store.deck(by: 1)?.shipId(of: damagedPos - 1) }
+            case 7...12: return store.sync { store.deck(by: 2)?.shipId(of: damagedPos - 6 - 1) }
             default: return nil
             }
         case 3:
-            return store.deck(by: 3)?.shipId(of: damagedPos - 1)
+            return store.sync { store.deck(by: 3)?.shipId(of: damagedPos - 1) }
         default:
             return nil
         }
@@ -71,40 +72,44 @@ final class GuardShelterCommand: JSONCommand {
         }
         
         let store = TemporaryDataStore.oneTimeEditor()
-        
-        guard let damaged = store.createGuardEscaped() else {
+        store.sync {
             
-            return Logger.shared.log("Can not create GuardEscaped for damaged")
-        }
-        
-        damaged.shipID = damagedId
-        damaged.ensured = false
-        
-        // store guardian if needs
-        guard let guardianPos = escape["api_tow_idx"][0].int else { return }
-        
-        let fixedGuardianPos = guardianPos - 6 - 1
-        
-        guard let guardianId = ServerDataStore.default.deck(by: 2)?.shipId(of: fixedGuardianPos) else {
+            guard let damaged = store.createGuardEscaped() else {
+                
+                return Logger.shared.log("Can not create GuardEscaped for damaged")
+            }
             
-            return Logger.shared.log("guardianPos is wrong")
-        }
-        
-        guard let guardian = store.createGuardEscaped() else {
+            damaged.shipID = damagedId
+            damaged.ensured = false
+            
+            // store guardian if needs
+            guard let guardianPos = escape["api_tow_idx"][0].int else { return }
+            
+            let fixedGuardianPos = guardianPos - 6 - 1
             
-            return Logger.shared.log("Can not create GuardEscaped for guardinan")
+            let sStore = ServerDataStore.default
+            guard let guardianId = sStore.sync(execute: { sStore.deck(by: 2)?.shipId(of: fixedGuardianPos) }) else {
+                
+                return Logger.shared.log("guardianPos is wrong")
+            }
+            
+            guard let guardian = store.createGuardEscaped() else {
+                
+                return Logger.shared.log("Can not create GuardEscaped for guardinan")
+            }
+            
+            guardian.shipID = guardianId
+            guardian.ensured = false
         }
-        
-        guardian.shipID = guardianId
-        guardian.ensured = false
     }
     
     private func removeInvalidEntry() {
         
         let store = TemporaryDataStore.oneTimeEditor()
-        
-        store.notEnsuredGuardEscaped().forEach(store.delete)
-        store.save(errorHandler: store.presentOnMainThread)
+        store.sync {
+            store.notEnsuredGuardEscaped().forEach(store.delete)
+            store.save(errorHandler: store.presentOnMainThread)
+        }
         Thread.sleep(forTimeInterval: 0.1)
         notify()
     }
@@ -112,9 +117,10 @@ final class GuardShelterCommand: JSONCommand {
     private func removeAllEntry() {
         
         let store = TemporaryDataStore.oneTimeEditor()
-        
-        store.guardEscaped().forEach(store.delete)
-        store.save(errorHandler: store.presentOnMainThread)
+        store.sync {
+            store.guardEscaped().forEach(store.delete)
+            store.save(errorHandler: store.presentOnMainThread)
+        }
         Thread.sleep(forTimeInterval: 0.1)
         notify()
     }
@@ -122,9 +128,10 @@ final class GuardShelterCommand: JSONCommand {
     private func ensureGuardShelter() {
         
         let store = TemporaryDataStore.oneTimeEditor()
-        
-        store.guardEscaped().forEach { $0.ensured = true }
-        store.save(errorHandler: store.presentOnMainThread)
+        store.sync {
+            store.guardEscaped().forEach { $0.ensured = true }
+            store.save(errorHandler: store.presentOnMainThread)
+        }
         Thread.sleep(forTimeInterval: 0.1)
         notify()
     }

--- a/KCD/HistoryItemCleaner.swift
+++ b/KCD/HistoryItemCleaner.swift
@@ -15,10 +15,13 @@ final class HistoryItemCleaner {
         guard UserDefaults.standard[.cleanOldHistoryItems] else { return }
         
         let store = LocalDataStore.oneTimeEditor()
-        let cleanSinceDays = UserDefaults.standard[.cleanSinceDays]
-        
-        store.unmarkedKaihatuHistories(befor: cleanSinceDays).forEach(store.delete)
-        store.unmarkedKenzoHistories(befor: cleanSinceDays).forEach(store.delete)
-        store.unmarkedDropShipHistories(befor: cleanSinceDays).forEach(store.delete)
+        store.sync {
+            
+            let cleanSinceDays = UserDefaults.standard[.cleanSinceDays]
+            
+            store.unmarkedKaihatuHistories(befor: cleanSinceDays).forEach(store.delete)
+            store.unmarkedKenzoHistories(befor: cleanSinceDays).forEach(store.delete)
+            store.unmarkedDropShipHistories(befor: cleanSinceDays).forEach(store.delete)
+        }
     }
 }

--- a/KCD/HistoryTableViewController.swift
+++ b/KCD/HistoryTableViewController.swift
@@ -49,10 +49,12 @@ class HistoryTableViewController: NSViewController {
         guard let selection = controller.selectedObjects as? [NSManagedObject] else { return }
         
         let selectedIndex = controller.selectionIndex
-        selection
-            .map { $0.objectID }
-            .map(store.object(with:))
-            .forEach(store.delete)
+        store.sync {
+            selection
+                .map { $0.objectID }
+                .map(store.object(with:))
+                .forEach(store.delete)
+        }
         
         if selectedIndex > 1 {
             
@@ -70,14 +72,16 @@ class HistoryTableViewController: NSViewController {
         let predicate = NSPredicate(#keyPath(KenzoMark.date), equal: clickedObject.date)
         
         let store = LocalDataStore.oneTimeEditor()
-        
-        if let items = try? objects(of: predicate, in: store),
-            var history = items.first as? Markable {
+        store.sync {
+            
+            if let items = try? self.objects(of: predicate, in: store),
+                var history = items.first as? Markable {
+                
+                history.mark = !history.mark
+            }
             
-            history.mark = !history.mark
+            store.save(errorHandler: store.presentOnMainThread)
         }
-        
-        store.save(errorHandler: store.presentOnMainThread)
     }
     
     override func validateMenuItem(_ menuItem: NSMenuItem) -> Bool {

--- a/KCD/JSONMapper.swift
+++ b/KCD/JSONMapper.swift
@@ -144,7 +144,7 @@ extension JSONMapper {
         }
     }
     
-    func commit() {
+    private func commintInContext() {
         
         let store = configuration.editorStore
         
@@ -174,6 +174,14 @@ extension JSONMapper {
         store.save(errorHandler: store.presentOnMainThread)
     }
     
+    func commit() {
+        
+        configuration.editorStore
+            .sync {
+                self.commintInContext()
+        }
+    }
+    
     func beginRegister(_ object: ObjectType) {}
     
     func handleExtraValue(_ value: JSON, forKey key: String, to object: ObjectType) -> Bool {

--- a/KCD/KaisouLockCommand.swift
+++ b/KCD/KaisouLockCommand.swift
@@ -28,6 +28,6 @@ final class KaisouLockCommand: JSONCommand {
         
         let store = ServerDataStore.oneTimeEditor()
         
-        store.slotItem(by: slotId)?.locked = (locked != 0)
+        store.sync { store.slotItem(by: slotId)?.locked = (locked != 0) }
     }
 }

--- a/KCD/KenzoMarkCommand.swift
+++ b/KCD/KenzoMarkCommand.swift
@@ -10,48 +10,69 @@ import Cocoa
 
 final class KenzoMarkCommand: JSONCommand {
     
+    struct KenzoDockInfo {
+        let dockId: Int
+        let shipId: Int
+        let fuel: Int
+        let bull: Int
+        let steel: Int
+        let bauxite: Int
+        let kaihatusizai: Int
+    }
+    
     override func execute() {
         
+        let store = LocalDataStore.oneTimeEditor()
+        store.sync {
+            self.executeInContext(localStore: store)
+        }
+    }
+    
+    private func executeInContext(localStore: LocalDataStore) {
+        
         guard let kdockId = parameter["api_kdock_id"].int else {
             
             return Logger.shared.log("api_kdock_id is wrong")
         }
         
         let store = ServerDataStore.default
-        
-        guard let kenzoDock = store.kenzoDock(by: kdockId) else {
+        guard let kenzoDock = store.sync(execute: { store.kenzoDock(by: kdockId) }) else {
             
-            return Logger.shared.log("KenzoDock is not fount")
+            return Logger.shared.log("KenzoDock is not found")
         }
-                
-        guard let flagShip = store.masterShip(by: kenzoDock.created_ship_id) else {
+        let kenzoDockInfo = store.sync {
+            KenzoDockInfo(dockId: kenzoDock.id,
+                          shipId: kenzoDock.created_ship_id,
+                          fuel: kenzoDock.item1,
+                          bull: kenzoDock.item2,
+                          steel: kenzoDock.item3,
+                          bauxite: kenzoDock.item4,
+                          kaihatusizai: kenzoDock.item5)
+        }
+        guard let flagShip = store.sync(execute: { store.masterShip(by: kenzoDock.created_ship_id) }) else {
             
             return Logger.shared.log("MasterShip is not found")
         }
         
-        let localStore = LocalDataStore.oneTimeEditor()
         guard let new = localStore.createKenzoHistory() else {
             
             return Logger.shared.log("Can not create KenzoHistory")
         }
         
-        new.name = flagShip.name
-        new.sTypeId = flagShip.stype.id
-        new.fuel = kenzoDock.item1
-        new.bull = kenzoDock.item2
-        new.steel = kenzoDock.item3
-        new.bauxite = kenzoDock.item4
-        new.kaihatusizai = kenzoDock.item5
+        new.name = store.sync { flagShip.name }
+        new.sTypeId = store.sync { flagShip.stype.id }
+        new.fuel = kenzoDockInfo.fuel
+        new.bull = kenzoDockInfo.bull
+        new.steel = kenzoDockInfo.steel
+        new.bauxite = kenzoDockInfo.bauxite
+        new.kaihatusizai = kenzoDockInfo.kaihatusizai
         new.date = Date()
-        (new.flagShipLv, new.flagShipName, new.commanderLv) = markedValues(kenzoDock: kenzoDock, kdockId: kdockId)
+        (new.flagShipLv, new.flagShipName, new.commanderLv) = markedValues(docInfo: kenzoDockInfo, in: localStore)
     }
     
-    private func markedValues(kenzoDock: KenzoDock, kdockId: Int) -> (Int, String, Int) {
-        
-        let store = LocalDataStore.default
+    private func markedValues(docInfo: KenzoDockInfo, in store: LocalDataStore) -> (Int, String, Int) {
         
-        if let kenzoMark = store.kenzoMark(kenzoDock: kenzoDock,
-                                           kDockId: kdockId) {
+        if let kenzoMark = store.kenzoMark(docInfo: docInfo) {
             
             return (kenzoMark.flagShipLv, kenzoMark.flagShipName, kenzoMark.commanderLv)
         }

--- a/KCD/LocalDataStoreAccessor.swift
+++ b/KCD/LocalDataStoreAccessor.swift
@@ -80,16 +80,16 @@ extension LocalDataStore {
         return kenzoMarks.first
     }
     
-    func kenzoMark(kenzoDock: KenzoDock, kDockId: Int) -> KenzoMark? {
+    func kenzoMark(docInfo: KenzoMarkCommand.KenzoDockInfo) -> KenzoMark? {
         
         let predicate = NSPredicate.empty
-            .and(NSPredicate(#keyPath(KenzoMark.fuel), equal: kenzoDock.item1))
-            .and(NSPredicate(#keyPath(KenzoMark.bull), equal: kenzoDock.item2))
-            .and(NSPredicate(#keyPath(KenzoMark.steel), equal: kenzoDock.item3))
-            .and(NSPredicate(#keyPath(KenzoMark.bauxite), equal: kenzoDock.item4))
-            .and(NSPredicate(#keyPath(KenzoMark.kaihatusizai), equal: kenzoDock.item5))
-            .and(NSPredicate(#keyPath(KenzoMark.created_ship_id), equal: kenzoDock.created_ship_id))
-            .and(NSPredicate(#keyPath(KenzoMark.kDockId), equal: kDockId))
+            .and(NSPredicate(#keyPath(KenzoMark.kDockId), equal: docInfo.dockId))
+            .and(NSPredicate(#keyPath(KenzoMark.fuel), equal: docInfo.fuel))
+            .and(NSPredicate(#keyPath(KenzoMark.bull), equal: docInfo.bull))
+            .and(NSPredicate(#keyPath(KenzoMark.steel), equal: docInfo.steel))
+            .and(NSPredicate(#keyPath(KenzoMark.bauxite), equal: docInfo.bauxite))
+            .and(NSPredicate(#keyPath(KenzoMark.kaihatusizai), equal: docInfo.kaihatusizai))
+            .and(NSPredicate(#keyPath(KenzoMark.created_ship_id), equal: docInfo.shipId))
         
         guard let kenzoMarks = try? objects(of: KenzoMark.entity, predicate: predicate) else { return nil }
         

--- a/KCD/MapInfoCommand.swift
+++ b/KCD/MapInfoCommand.swift
@@ -18,9 +18,10 @@ final class MapInfoCommand: JSONCommand {
     override func execute() {
         
         let store = ServerDataStore.oneTimeEditor()
-        
-        store.airBases().forEach(store.delete)
-        store.save(errorHandler: store.presentOnMainThread)
+        store.sync {
+            store.airBases().forEach(store.delete)
+            store.save(errorHandler: store.presentOnMainThread)
+        }
         
         AirBaseMapper(apiResponse).commit()
     }

--- a/KCD/MapStartCommand.swift
+++ b/KCD/MapStartCommand.swift
@@ -34,7 +34,7 @@ final class MapStartCommand: JSONCommand {
     
     private func startBattle() {
         
-        store.battles().forEach(store.delete)
+        store.sync { self.store.battles().forEach(self.store.delete) }
         
         guard let deckId = parameter["api_deck_id"].int,
             let mapArea = parameter["api_maparea_id"].int,
@@ -48,18 +48,21 @@ final class MapStartCommand: JSONCommand {
             return Logger.shared.log("startBattle JSON is wrong")
         }
         
-        guard let battle = store.createBattle() else {
+        guard let battle = store.sync(execute: { self.store.createBattle() }) else {
             
             return Logger.shared.log("Can not create Battle")
         }
         
         let kcd = ServerDataStore.default
         
-        battle.deckId = deckId
-        battle.mapArea = mapArea
-        battle.mapInfo = mapInfo
-        battle.no = no
-        battle.firstFleetShipsCount = kcd.ships(byDeckId: deckId).count
+        store.sync {
+            
+            battle.deckId = deckId
+            battle.mapArea = mapArea
+            battle.mapInfo = mapInfo
+            battle.no = no
+            battle.firstFleetShipsCount = kcd.sync { kcd.ships(byDeckId: deckId).count }
+        }
     }
     
     private func nextCell() {
@@ -70,14 +73,23 @@ final class MapStartCommand: JSONCommand {
                 return Logger.shared.log("updateBattleCell JSON is wrong")
         }
         
-        guard let battle = store.battle() else { return Logger.shared.log("Battle is invalid.") }
+        guard let battle = store.sync(execute: { self.store.battle() }) else {
+            
+            return Logger.shared.log("Battle is invalid.")
+        }
         
-        battle.no = cellNumber
-        battle.isBossCell = (eventId == 5)
+        store.sync {
+            
+            battle.no = cellNumber
+            battle.isBossCell = (eventId == 5)
+        }
     }
     
     private func updateBattleCell() {
         
-        store.battle().map { $0.battleCell = nil }
+        store.sync {
+            
+            self.store.battle().map { $0.battleCell = nil }
+        }
     }
 }

--- a/KCD/MasterShipMapper.swift
+++ b/KCD/MasterShipMapper.swift
@@ -23,7 +23,9 @@ final class MasterShipMapper: JSONMapper {
     
     private lazy var masterSTypes: [MasterSType] = {
         
-        return ServerDataStore.default.sortedMasterSTypesById()
+        guard let store = configuration.editorStore as? ServerDataStore else { return [] }
+        
+        return store.sortedMasterSTypesById()
     }()
     
     func handleExtraValue(_ value: JSON, forKey key: String, to masterShip: MasterShip) -> Bool {

--- a/KCD/MaterialMapper.swift
+++ b/KCD/MaterialMapper.swift
@@ -43,6 +43,10 @@ final class MaterialMapper: JSONMapper {
     
     func commit() {
         
+        configuration.editorStore.sync(execute: commintInContext)
+    }
+    private func commintInContext() {
+        
         guard let store = configuration.editorStore as? ServerDataStore,
             let material = store.material() ?? store.createMaterial() else {
                 

--- a/KCD/NyukyoSpeedChangeCommand.swift
+++ b/KCD/NyukyoSpeedChangeCommand.swift
@@ -18,13 +18,14 @@ final class NyukyoSpeedChangeCommand: JSONCommand {
     override func execute() {
         
         let store = ServerDataStore.oneTimeEditor()
-        
-        let nDock = parameter["api_ndock_id"].int.flatMap(store.nyukyoDock(by:))
-        
-        nDock.flatMap { $0.ship_id }.flatMap(store.ship(by:)).map { $0.nowhp = $0.maxhp }
-        nDock?.ship_id = 0
-        nDock?.state = 0
-        
-        store.material().map { $0.kousokushuhuku = $0.kousokushuhuku - 1 }
+        store.sync {
+            let nDock = self.parameter["api_ndock_id"].int.flatMap(store.nyukyoDock(by:))
+            
+            nDock.flatMap { $0.ship_id }.flatMap(store.ship(by:)).map { $0.nowhp = $0.maxhp }
+            nDock?.ship_id = 0
+            nDock?.state = 0
+            
+            store.material().map { $0.kousokushuhuku = $0.kousokushuhuku - 1 }
+        }
     }
 }

--- a/KCD/NyukyoStartCommand.swift
+++ b/KCD/NyukyoStartCommand.swift
@@ -20,13 +20,14 @@ final class NyukyoStartCommand: JSONCommand {
         guard let hi = parameter["api_highspeed"].int, hi != 0 else { return }
         
         let store = ServerDataStore.oneTimeEditor()
-        
-        parameter["api_ship_id"]
-            .int
-            .flatMap(store.ship(by:))
-            .map { $0.nowhp = $0.maxhp }
-        
-        store.material()
-            .map { $0.kousokushuhuku = $0.kousokushuhuku - 1 }
+        store.sync {
+            self.parameter["api_ship_id"]
+                .int
+                .flatMap(store.ship(by:))
+                .map { $0.nowhp = $0.maxhp }
+            
+            store.material()
+                .map { $0.kousokushuhuku = $0.kousokushuhuku - 1 }
+        }
     }
 }

--- a/KCD/QuestListCommand.swift
+++ b/KCD/QuestListCommand.swift
@@ -36,31 +36,36 @@ final class QuestListCommand: JSONCommand {
         let lastQuestNumber = questNumberList?.last ?? 9999
         let minNo = (page == 1) ? 0 : firstQuestNumber
         let maxNo = (page == pageCount) ? 9999 : lastQuestNumber
-        store.quests(in: minNo...maxNo).forEach { $0.state = 1 }
+        store.sync { store.quests(in: minNo...maxNo).forEach { $0.state = 1 } }
         
         // 新しいデータ投入
-        let quests = store.sortedQuestByNo()
+        let quests = store.sync { store.sortedQuestByNo() }
         questList.forEach { _, quest in
             
             guard let no = quest["api_no"].int else { return }
             
-            let t = quests.binarySearch { $0.no ==? no }
+            let t = store.sync { quests.binarySearch { $0.no ==? no } }
             
-            guard let new = t ?? store.createQuest() else { return Logger.shared.log("Can not create Quest") }
+            guard let new = t ?? store.sync(execute: { store.createQuest() }) else {
+                
+                return Logger.shared.log("Can not create Quest")
+            }
             
-            new.bonus_flag = quest["api_bonus_flag"].int.map { $0 != 0 } ?? false
-            new.category = quest["api_category"].int ?? 0
-            new.detail = quest["api_detail"].string ?? ""
-//            new.get_material_0 = questData["api_get_material_0"] as? Int ?? 0
-//            new.get_material_1 = questData["api_get_material_1"] as? Int ?? 0
-//            new.get_material_2 = questData["api_get_material_2"] as? Int ?? 0
-//            new.get_material_3 = questData["api_get_material_3"] as? Int ?? 0
-            new.invalid_flag = quest["api_invalid_flag"].int ?? 0
-            new.no = quest["api_no"].int ?? 0
-            new.progress_flag = quest["api_progress_flag"].int ?? 0
-            new.state = quest["api_state"].int ?? 0
-            new.title = quest["api_title"].string ?? ""
-            new.type = quest["api_type"].int ?? 0
+            store.sync {
+                new.bonus_flag = quest["api_bonus_flag"].int.map { $0 != 0 } ?? false
+                new.category = quest["api_category"].int ?? 0
+                new.detail = quest["api_detail"].string ?? ""
+//                new.get_material_0 = questData["api_get_material_0"] as? Int ?? 0
+//                new.get_material_1 = questData["api_get_material_1"] as? Int ?? 0
+//                new.get_material_2 = questData["api_get_material_2"] as? Int ?? 0
+//                new.get_material_3 = questData["api_get_material_3"] as? Int ?? 0
+                new.invalid_flag = quest["api_invalid_flag"].int ?? 0
+                new.no = quest["api_no"].int ?? 0
+                new.progress_flag = quest["api_progress_flag"].int ?? 0
+                new.state = quest["api_state"].int ?? 0
+                new.title = quest["api_title"].string ?? ""
+                new.type = quest["api_type"].int ?? 0
+            }
         }
     }
 }

--- a/KCD/RealDestroyShipCommand.swift
+++ b/KCD/RealDestroyShipCommand.swift
@@ -13,21 +13,23 @@ final class RealDestroyShipCommand: JSONCommand {
     override func execute() {
         
         let store = ServerDataStore.oneTimeEditor()
-        
-        let ships = parameter["api_ship_id"]
-            .integerArray
-            .flatMap(store.ship(by:))
-        
-        if parameter["api_slot_dest_flag"].int == 0 {
+        store.sync {
+            
+            let ships = self.parameter["api_ship_id"]
+                .integerArray
+                .flatMap(store.ship(by:))
             
-            // remove allEquipment
-            ships.forEach {
+            if self.parameter["api_slot_dest_flag"].int == 0 {
+                
+                // remove allEquipment
+                ships.forEach {
                     $0.equippedItem = []
                     $0.extraItem = nil
+                }
             }
+            
+            // destory ships
+            ships.forEach(store.delete)
         }
-        
-        // destory ships
-        ships.forEach(store.delete)
     }
 }

--- a/KCD/RealPowerUpCommand.swift
+++ b/KCD/RealPowerUpCommand.swift
@@ -13,10 +13,11 @@ final class RealPowerUpCommand: JSONCommand {
     override func execute() {
         
         let store = ServerDataStore.oneTimeEditor()
-        
-        parameter["api_id_items"]
-            .integerArray
-            .flatMap(store.ship(by:))
-            .forEach(store.delete)
+        store.sync {
+            self.parameter["api_id_items"]
+                .integerArray
+                .flatMap(store.ship(by:))
+                .forEach(store.delete)
+        }
     }
 }

--- a/KCD/RemodelSlotItemCommand.swift
+++ b/KCD/RemodelSlotItemCommand.swift
@@ -20,32 +20,33 @@ final class RemodelSlotItemCommand: JSONCommand {
         
         let afterSlot = data["api_after_slot"]
         let store = ServerDataStore.oneTimeEditor()
-        
-        guard let slotItem = store.slotItem(by: slotItemId) else {
+        store.sync {
+            guard let slotItem = store.slotItem(by: slotItemId) else {
+                
+                return Logger.shared.log("SlotItem not found")
+            }
             
-            return Logger.shared.log("SlotItem not found")
-        }
-
-        if let locked = afterSlot["api_locked"].int {
-            
-            slotItem.locked = (locked != 0)
-        }
-        if let masterSlotItemId = afterSlot["api_slotitem_id"].int,
-            masterSlotItemId != slotItem.slotitem_id,
-            let masterSlotItem = store.masterSlotItem(by: slotItemId) {
+            if let locked = afterSlot["api_locked"].int {
+                
+                slotItem.locked = (locked != 0)
+            }
+            if let masterSlotItemId = afterSlot["api_slotitem_id"].int,
+                masterSlotItemId != slotItem.slotitem_id,
+                let masterSlotItem = store.masterSlotItem(by: slotItemId) {
+                
+                slotItem.master_slotItem = masterSlotItem
+                slotItem.slotitem_id = slotItemId
+                
+            }
+            if let level = afterSlot["api_level"].int {
+                
+                slotItem.level = level
+            }
             
-            slotItem.master_slotItem = masterSlotItem
-            slotItem.slotitem_id = slotItemId
+            // remove used slot items.
+            guard let useSlot = self.data["api_use_slot_id"].arrayObject as? [Int] else { return }
             
+            store.slotItems(in: useSlot).forEach(store.delete)
         }
-        if let level = afterSlot["api_level"].int {
-            
-            slotItem.level = level
-        }
-        
-        // remove used slot items.
-        guard let useSlot = data["api_use_slot_id"].arrayObject as? [Int] else { return }
-        
-        store.slotItems(in: useSlot).forEach(store.delete)
     }
 }

--- a/KCD/ResetSortie.swift
+++ b/KCD/ResetSortie.swift
@@ -14,6 +14,6 @@ final class ResetSortie {
         
         let store = TemporaryDataStore.oneTimeEditor()
         
-        store.battles().forEach(store.delete)
+        store.sync { store.battles().forEach(store.delete) }
     }
 }

--- a/KCD/ResourceHistoryManager.swift
+++ b/KCD/ResourceHistoryManager.swift
@@ -63,40 +63,41 @@ final class ResourceHistoryManager: NSObject {
             return Logger.shared.log("ResourceHistoryManager: Can not get Material")
         }
         
-        guard let basic = store.basic() else {
+        guard let experience = store.sync(execute: { store.basic()?.experience }) else {
             
             return Logger.shared.log("ResourceHistoryManager: Can not get Basic")
         }
         
         let historyStore = ResourceHistoryDataStore.oneTimeEditor()
-        
-        guard let newHistory = historyStore.createResource() else {
+        historyStore.sync {
+            guard let newHistory = historyStore.createResource() else {
+                
+                return Logger.shared.log("ResourceHistoryManager: Can not create ResourceHIstory")
+            }
+            
+            let now = Date()
+            var nowComp = Calendar.current
+                .dateComponents([.year, .month, .day, .hour, .minute], from: now)
+            let minutes = nowComp.minute.map { ($0 + 2) / 5 } ?? 0
+            nowComp.minute = minutes * 5
             
-            return Logger.shared.log("ResourceHistoryManager: Can not create ResourceHIstory")
+            newHistory.date = Calendar.current.date(from: nowComp)!
+            newHistory.minute = (minutes != 60) ? minutes : 0
+            newHistory.fuel = store.sync { material.fuel }
+            newHistory.bull = store.sync { material.bull }
+            newHistory.steel = store.sync { material.steel }
+            newHistory.bauxite = store.sync { material.bauxite }
+            newHistory.kaihatusizai = store.sync { material.kaihatusizai }
+            newHistory.kousokukenzo = store.sync { material.kousokukenzo }
+            newHistory.kousokushuhuku = store.sync { material.kousokushuhuku }
+            newHistory.screw = store.sync { material.screw }
+            newHistory.experience = experience
         }
-        
-        let now = Date()
-        var nowComp = Calendar.current
-            .dateComponents([.year, .month, .day, .hour, .minute], from: now)
-        let minutes = nowComp.minute.map { ($0 + 2) / 5 } ?? 0
-        nowComp.minute = minutes * 5
-        
-        newHistory.date = Calendar.current.date(from: nowComp)!
-        newHistory.minute = (minutes != 60) ? minutes : 0
-        newHistory.fuel = material.fuel
-        newHistory.bull = material.bull
-        newHistory.steel = material.steel
-        newHistory.bauxite = material.bauxite
-        newHistory.kaihatusizai = material.kaihatusizai
-        newHistory.kousokukenzo = material.kousokukenzo
-        newHistory.kousokushuhuku = material.kousokushuhuku
-        newHistory.screw = material.screw
-        newHistory.experience = basic.experience
     }
     
     private func reduceResourceByConditions(_ store: ResourceHistoryDataStore, _ target: [Int], _ ago: Date) {
         
-        store.resources(in: target, older: ago).forEach(store.delete)
+        store.sync { store.resources(in: target, older: ago).forEach(store.delete) }
     }
     
     private func dateOfMonth(_ month: Int) -> Date {

--- a/KCD/SetActionCommand.swift
+++ b/KCD/SetActionCommand.swift
@@ -27,10 +27,11 @@ final class SetActionCommand: JSONCommand {
         if rIds.count != actions.count { print("missmatch count") }
         
         let store = ServerDataStore.oneTimeEditor()
-        
-        zip(rIds, actions).forEach { (rId, action) in
-            
-            store.airBase(area: areaId, base: rId)?.action_kind = action
+        store.sync {
+            zip(rIds, actions).forEach { rId, action in
+                
+                store.airBase(area: areaId, base: rId)?.action_kind = action
+            }
         }
     }
 }

--- a/KCD/SetPlaneCommand.swift
+++ b/KCD/SetPlaneCommand.swift
@@ -37,29 +37,31 @@ final class SetPlaneCommand: JSONCommand {
         }
         
         let store = ServerDataStore.oneTimeEditor()
-        
-        guard let airbase = store.airBase(area: areaId, base: rId) else {
+        store.sync {
             
-            return Logger.shared.log("AirBase is not found")
-        }
-        
-        let planes = airbase.planeInfo
-        
-        guard planes.count >= squadronId,
-            let plane = planes[squadronId - 1] as? AirBasePlaneInfo else {
+            guard let airbase = store.airBase(area: areaId, base: rId) else {
                 
-                return Logger.shared.log("AirBase is wrong")
+                return Logger.shared.log("AirBase is not found")
+            }
+            
+            let planes = airbase.planeInfo
+            
+            guard planes.count >= squadronId,
+                let plane = planes[squadronId - 1] as? AirBasePlaneInfo else {
+                    
+                    return Logger.shared.log("AirBase is wrong")
+            }
+            
+            // TODO: state が 2 の時のみ cond, count, max_count がnilであることを許すようにする
+            plane.cond = planInfo["api_cond"].int ?? 0
+            plane.slotid = slotid
+            plane.state = state
+            plane.count = planInfo["api_count"].int ?? 0
+            plane.max_count = planInfo["api_max_count"].int ?? 0
+            
+            airbase.distance = distance
+            
+            self.data["api_after_bauxite"].int.map { store.material()?.bauxite = $0 }
         }
-        
-        // TODO: state が 2 の時のみ cond, count, max_count がnilであることを許すようにする
-        plane.cond = planInfo["api_cond"].int ?? 0
-        plane.slotid = slotid
-        plane.state = state
-        plane.count = planInfo["api_count"].int ?? 0
-        plane.max_count = planInfo["api_max_count"].int ?? 0
-        
-        airbase.distance = distance
-        
-        data["api_after_bauxite"].int.map { store.material()?.bauxite = $0 }
     }
 }

--- a/KCD/ShipMapper.swift
+++ b/KCD/ShipMapper.swift
@@ -61,12 +61,18 @@ final class ShipMapper: JSONMapper {
     private var registerIds: [Int] = []
     private lazy var masterShips: [MasterShip] = {
         
-        return ServerDataStore.default.sortedMasterShipsById()
+        guard let store = configuration.editorStore as? ServerDataStore else { return [] }
+        
+        return store.sortedMasterShipsById()
+        
     }()
     private lazy var slotItems: [SlotItem] = {
         
-        return ServerDataStore.default.sortedSlotItemsById()
+        guard let store = configuration.editorStore as? ServerDataStore else { return [] }
+        
+        return store.sortedSlotItemsById()
     }()
+    
     private var needsDeleteUnregisteredShip: Bool {
         
         switch apiResponse.api.endpoint {

--- a/KCD/ShipMasterDetailWindowController.swift
+++ b/KCD/ShipMasterDetailWindowController.swift
@@ -68,30 +68,31 @@ final class ShipMasterDetailWindowController: NSWindowController {
     @IBAction func applySally(_ sender: AnyObject?) {
         
         let store = ServerDataStore.oneTimeEditor()
-        
-        guard let i = selectedShip?.objectID else { return }
-        guard let ship = store.object(of: Ship.entity, with: i) else { return }
-//
-//        ship.sally_area = sally.integerValue as NSNumber
-        
-        let eq = ship.equippedItem.array
-        let slotId = sally.integerValue
-        
-        let pos = min(4, eq.count)
-        
-        if eq.count > 4 {
+        store.sync {
+            guard let i = self.selectedShip?.objectID else { return }
+            guard let ship = store.object(of: Ship.entity, with: i) else { return }
+            //
+            //        ship.sally_area = sally.integerValue as NSNumber
             
-            ship.equippedItem = NSOrderedSet(array: Array(eq.dropLast()))
-        }
-        
-        if let slotItem = store.slotItem(by: slotId) {
+            let eq = ship.equippedItem.array
+            let slotId = self.sally.integerValue
+            
+            let pos = min(4, eq.count)
             
-            ship.setItem(slotId, to: pos)
+            if eq.count > 4 {
+                
+                ship.equippedItem = NSOrderedSet(array: Array(eq.dropLast()))
+            }
             
-            ship.equippedItem = NSOrderedSet(array: ship.equippedItem.array + [slotItem])
+            if let slotItem = store.slotItem(by: slotId) {
+                
+                ship.setItem(slotId, to: pos)
+                
+                ship.equippedItem = NSOrderedSet(array: ship.equippedItem.array + [slotItem])
+            }
+            
+            store.save(errorHandler: {_ in})
         }
-        
-        store.save(errorHandler: {_ in})
     }
 }
 

--- a/KCD/SlotItemMapper.swift
+++ b/KCD/SlotItemMapper.swift
@@ -38,7 +38,10 @@ final class SlotItemMapper: JSONMapper {
     
     private var registerIds: [Int] = []
     private lazy var masterSlotItems: [MasterSlotItem] = {
-        return ServerDataStore.default.sortedMasterSlotItemsById()
+        
+        guard let store = configuration.editorStore as? ServerDataStore else { return [] }
+        
+        return store.sortedMasterSlotItemsById()
     }()
     
     func beginRegister(_ slotItem: SlotItem) {

--- a/KCD/SlotResetCommand.swift
+++ b/KCD/SlotResetCommand.swift
@@ -18,31 +18,33 @@ final class SlotResetCommand: JSONCommand {
     override func execute() {
         
         let store = ServerDataStore.oneTimeEditor()
-        
-        guard let ship = parameter["api_id"].int.flatMap(store.ship(by:)) else {
-            
-            return Logger.shared.log("api_id is wrong")
-        }
-        guard let slotItems = data["api_slot"].arrayObject as? [Int] else {
+        store.sync {
             
-            return Logger.shared.log("Can not parse api_data.api_slot")
-        }
-        
-        zip(slotItems, 0...).forEach(ship.setItem)
-        
-        let storedSlotItems = store.sortedSlotItemsById()
-        let newSet = slotItems
-            .flatMap { slotItem -> SlotItem? in
+            guard let ship = self.parameter["api_id"].int.flatMap(store.ship(by:)) else {
                 
-                guard slotItem > 0 else { return nil }
+                return Logger.shared.log("api_id is wrong")
+            }
+            guard let slotItems = self.data["api_slot"].arrayObject as? [Int] else {
                 
-                let found = storedSlotItems.binarySearch { $0.id ==? slotItem }
-                if let item = found { return item }
-                print("Item \(slotItem) is not found")
-                
-                return nil
+                return Logger.shared.log("Can not parse api_data.api_slot")
+            }
+            
+            zip(slotItems, 0...).forEach(ship.setItem)
+            
+            let storedSlotItems = store.sortedSlotItemsById()
+            let newSet = slotItems
+                .flatMap { slotItem -> SlotItem? in
+                    
+                    guard slotItem > 0 else { return nil }
+                    
+                    let found = storedSlotItems.binarySearch { $0.id ==? slotItem }
+                    if let item = found { return item }
+                    print("Item \(slotItem) is not found")
+                    
+                    return nil
+            }
+            
+            ship.equippedItem = NSOrderedSet(array: newSet)
         }
-        
-        ship.equippedItem = NSOrderedSet(array: newSet)
     }
 }

--- a/KCD/StoreCreateSlotItemHistoryCommand.swift
+++ b/KCD/StoreCreateSlotItemHistoryCommand.swift
@@ -26,31 +26,35 @@ final class StoreCreateSlotItemHistoryCommand: JSONCommand {
         let numberOfUsedKaihatuSizai = (success != 0 ? 1 : 0)
         
         let store = ServerDataStore.default
-        
-        guard let flagShip = store.deck(by: 1)?[0] else {
+        guard let flagShip = store.sync(execute: { store.deck(by: 1)?[0] }) else {
             
             return Logger.shared.log("Flagship is not found")
         }
         
-        guard let basic = store.basic() else { return print("Basic is wrong") }
+        guard let commanderLv = store.sync(execute: { store.basic()?.level }) else {
+            
+            return print("Basic is wrong")
+        }
         
         let localStore = LocalDataStore.oneTimeEditor()
-        
-        guard let newHistory = localStore.createKaihatuHistory() else {
+        guard let newHistory = localStore.sync(execute: { localStore.createKaihatuHistory() }) else {
             
             return Logger.shared.log("Can not create new KaihatuHistory entry")
         }
         
-        newHistory.name = name
-        newHistory.fuel = fuel
-        newHistory.bull = bull
-        newHistory.steel = steel
-        newHistory.bauxite = bauxite
-        newHistory.kaihatusizai = numberOfUsedKaihatuSizai
-        newHistory.flagShipLv = flagShip.lv
-        newHistory.flagShipName = flagShip.name
-        newHistory.commanderLv = basic.level
-        newHistory.date = Date()
+        localStore.sync {
+            
+            newHistory.name = name
+            newHistory.fuel = fuel
+            newHistory.bull = bull
+            newHistory.steel = steel
+            newHistory.bauxite = bauxite
+            newHistory.kaihatusizai = numberOfUsedKaihatuSizai
+            newHistory.flagShipLv = store.sync { flagShip.lv }
+            newHistory.flagShipName = store.sync { flagShip.name }
+            newHistory.commanderLv = commanderLv
+            newHistory.date = Date()
+        }
     }
     
     private func masterSlotItemName(sccess: Int, data: JSON) -> String {
@@ -65,6 +69,7 @@ final class StoreCreateSlotItemHistoryCommand: JSONCommand {
             return Logger.shared.log("api_slotitem_id is wrong", value: "")
         }
         
-        return ServerDataStore.default.masterSlotItem(by: slotItemId)?.name ?? ""
+        let store = ServerDataStore.default
+        return store.sync { store.masterSlotItem(by: slotItemId)?.name ?? "" }
     }
 }

--- a/KCD/TSVSupport.swift
+++ b/KCD/TSVSupport.swift
@@ -95,10 +95,17 @@ final class TSVSupport {
             
             guard $0 == .OK else { return }
             guard let url = panel.url else { return }
-            guard let kaihatuHistory = self.dataOfKaihatuHistory() else { return }
-            guard let kenzoHistory = self.dataOfKenzoHistory() else { return }
-            guard let kenzoMark = self.dataOfKenzoMark() else { return }
-            guard let dropShipHistory = self.dataOfDropShipHistory() else { return }
+            
+            let data = self.store.sync { () -> (Data, Data, Data, Data)? in
+                
+                guard let kaihatuHistory = self.dataOfKaihatuHistory() else { return nil }
+                guard let kenzoHistory = self.dataOfKenzoHistory() else { return nil }
+                guard let kenzoMark = self.dataOfKenzoMark() else { return nil }
+                guard let dropShipHistory = self.dataOfDropShipHistory() else { return nil }
+                
+                return (kaihatuHistory, kenzoHistory, kenzoMark, dropShipHistory)
+            }
+            guard let (kaihatuHistory, kenzoHistory, kenzoMark, dropShipHistory) = data else { return }
             
             let fileW = FileWrapper(directoryWithFileWrappers: [:])
             fileW.addRegularFile(withContents: kaihatuHistory, preferredFilename: "kaihatu.tsv")
@@ -217,7 +224,6 @@ final class TSVSupport {
     private func registerKaihatuHistory(_ data: Data) {
         
         let array = String(data: data, encoding: .utf8)?.components(separatedBy: "\n")
-        let store = LocalDataStore.oneTimeEditor()
         array?.forEach {
             
             let attr = $0.components(separatedBy: "\t")
@@ -254,7 +260,6 @@ final class TSVSupport {
     private func registerKenzoHistory(_ data: Data) {
         
         let array = String(data: data, encoding: .utf8)?.components(separatedBy: "\n")
-        let store = LocalDataStore.oneTimeEditor()
         
         array?.forEach {
             
@@ -294,7 +299,6 @@ final class TSVSupport {
     private func registerKenzoMark( _ data: Data) {
         
         let array = String(data: data, encoding: .utf8)?.components(separatedBy: "\n")
-        let store = LocalDataStore.oneTimeEditor()
         
         array?.forEach {
             
@@ -335,7 +339,6 @@ final class TSVSupport {
     private func registerDropShipHistory( _ data: Data) {
         
         let array = String(data: data, encoding: .utf8)?.components(separatedBy: "\n")
-        let store = LocalDataStore.oneTimeEditor()
         
         array?.forEach {
             

--- a/KCD/UpdateQuestListCommand.swift
+++ b/KCD/UpdateQuestListCommand.swift
@@ -13,13 +13,14 @@ final class UpdateQuestListCommand: JSONCommand {
     override func execute() {
         
         let store = ServerDataStore.oneTimeEditor()
-        
-        parameter["api_quest_id"]
-            .int
-            .flatMap(store.quest(by:))
-            .map {
-                $0.progress_flag = 0
-                $0.state = 1
+        store.sync {
+            self.parameter["api_quest_id"]
+                .int
+                .flatMap(store.quest(by:))
+                .map {
+                    $0.progress_flag = 0
+                    $0.state = 1
+            }
         }
     }
 }

--- a/KCD/UpdateSlotItemCommand.swift
+++ b/KCD/UpdateSlotItemCommand.swift
@@ -23,17 +23,19 @@ final class UpdateSlotItemCommand: JSONCommand {
         
         let store = ServerDataStore.oneTimeEditor()
         
-        guard let masterSlotItem = store.masterSlotItem(by: slotItemId) else {
+        guard let masterSlotItem = store.sync(execute: { store.masterSlotItem(by: slotItemId) }) else {
             
             return Logger.shared.log("MasterSlotItem is not found")
         }
         
-        guard let new = store.createSlotItem() else {
+        guard let new = store.sync(execute: { store.createSlotItem() }) else {
             
             return Logger.shared.log("Can not create new SlotItem")
         }
         
-        new.id = newSlotItemId
-        new.master_slotItem = masterSlotItem
+        store.sync {
+            new.id = newSlotItemId
+            new.master_slotItem = masterSlotItem
+        }
     }
 }