Updated pod spec version to 0.8.1

Fixed bug in Data(value:) initializer. Switch uuid init via this
Merge pull request #16 from RndmTsk/master
2016-12-07 02:36:49 +03:30 · 2016-12-07 02:34:34 +03:30 · 2016-12-07 02:29:28 +03:30 · 2016-12-06 17:18:41 -05:00 · 2016-12-06 10:51:58 +03:30 · 2016-12-06 14:51:48 +08:00
24 changed files with 1300 additions and 1039 deletions
@@ -16,7 +16,7 @@ Pod::Spec.new do |s|
  #

  s.name         = "FileProvider"
-  s.version      = "0.6.1"
+  s.version      = "0.8.1"
  s.summary      = "FileManager replacement for Local and Remote (WebDAV/Dropbox/SMB2) files on iOS and macOS."

  # This description is used to generate tags and improve search results.
@@ -11,9 +11,6 @@
 		7902C0871D61B67100564440 /* RemoteSession.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7902C0851D61B56D00564440 /* RemoteSession.swift */; };
 		7902C0881D61B67100564440 /* RemoteSession.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7902C0851D61B56D00564440 /* RemoteSession.swift */; };
 		791950F51DE58A5400B4426E /* libxml2.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = 791950F41DE58A5400B4426E /* libxml2.tbd */; };
-		7924B1931D89DAE000589DB7 /* AEXML.h in Headers */ = {isa = PBXBuildFile; fileRef = 7924B18C1D89DAE000589DB7 /* AEXML.h */; };
-		7924B1941D89DAE000589DB7 /* AEXML.h in Headers */ = {isa = PBXBuildFile; fileRef = 7924B18C1D89DAE000589DB7 /* AEXML.h */; };
-		7924B1951D89DAE000589DB7 /* AEXML.h in Headers */ = {isa = PBXBuildFile; fileRef = 7924B18C1D89DAE000589DB7 /* AEXML.h */; };
 		7924B1961D89DAE000589DB7 /* Document.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7924B18D1D89DAE000589DB7 /* Document.swift */; };
 		7924B1971D89DAE000589DB7 /* Document.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7924B18D1D89DAE000589DB7 /* Document.swift */; };
 		7924B1981D89DAE000589DB7 /* Document.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7924B18D1D89DAE000589DB7 /* Document.swift */; };
@@ -23,9 +20,6 @@
 		7924B19C1D89DAE000589DB7 /* Error.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7924B18F1D89DAE000589DB7 /* Error.swift */; };
 		7924B19D1D89DAE000589DB7 /* Error.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7924B18F1D89DAE000589DB7 /* Error.swift */; };
 		7924B19E1D89DAE000589DB7 /* Error.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7924B18F1D89DAE000589DB7 /* Error.swift */; };
-		7924B19F1D89DAE000589DB7 /* Info.plist in Resources */ = {isa = PBXBuildFile; fileRef = 7924B1901D89DAE000589DB7 /* Info.plist */; };
-		7924B1A01D89DAE000589DB7 /* Info.plist in Resources */ = {isa = PBXBuildFile; fileRef = 7924B1901D89DAE000589DB7 /* Info.plist */; };
-		7924B1A11D89DAE000589DB7 /* Info.plist in Resources */ = {isa = PBXBuildFile; fileRef = 7924B1901D89DAE000589DB7 /* Info.plist */; };
 		7924B1A21D89DAE000589DB7 /* Options.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7924B1911D89DAE000589DB7 /* Options.swift */; };
 		7924B1A31D89DAE000589DB7 /* Options.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7924B1911D89DAE000589DB7 /* Options.swift */; };
 		7924B1A41D89DAE000589DB7 /* Options.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7924B1911D89DAE000589DB7 /* Options.swift */; };
@@ -38,6 +32,9 @@
 		7924B1B11D89F7DF00589DB7 /* FPSStreamTask.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7924B1A81D89F79200589DB7 /* FPSStreamTask.swift */; };
 		7924B1B21D89FCDA00589DB7 /* FPSStreamTask.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7924B1A81D89F79200589DB7 /* FPSStreamTask.swift */; };
 		7924B1B31D89FD6400589DB7 /* SMBClient.swift in Sources */ = {isa = PBXBuildFile; fileRef = 799396971D48C02300086753 /* SMBClient.swift */; };
+		792572411DF23BDA006A1526 /* LocalHelper.swift in Sources */ = {isa = PBXBuildFile; fileRef = 792572401DF23BDA006A1526 /* LocalHelper.swift */; };
+		792572421DF23BDA006A1526 /* LocalHelper.swift in Sources */ = {isa = PBXBuildFile; fileRef = 792572401DF23BDA006A1526 /* LocalHelper.swift */; };
+		792572431DF23BDA006A1526 /* LocalHelper.swift in Sources */ = {isa = PBXBuildFile; fileRef = 792572401DF23BDA006A1526 /* LocalHelper.swift */; };
 		794C21FE1D58912A00EC49B8 /* DropboxHelper.swift in Sources */ = {isa = PBXBuildFile; fileRef = 794C21FD1D58912A00EC49B8 /* DropboxHelper.swift */; };
 		794C21FF1D58912A00EC49B8 /* DropboxHelper.swift in Sources */ = {isa = PBXBuildFile; fileRef = 794C21FD1D58912A00EC49B8 /* DropboxHelper.swift */; };
 		794C22001D58912A00EC49B8 /* DropboxHelper.swift in Sources */ = {isa = PBXBuildFile; fileRef = 794C21FD1D58912A00EC49B8 /* DropboxHelper.swift */; };
@@ -100,14 +97,13 @@
 /* Begin PBXFileReference section */
 		7902C0851D61B56D00564440 /* RemoteSession.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = RemoteSession.swift; sourceTree = "<group>"; };
 		791950F41DE58A5400B4426E /* libxml2.tbd */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.text-based-dylib-definition"; name = libxml2.tbd; path = Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS10.1.sdk/usr/lib/libxml2.tbd; sourceTree = DEVELOPER_DIR; };
-		7924B18C1D89DAE000589DB7 /* AEXML.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AEXML.h; sourceTree = "<group>"; };
 		7924B18D1D89DAE000589DB7 /* Document.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Document.swift; sourceTree = "<group>"; };
 		7924B18E1D89DAE000589DB7 /* Element.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Element.swift; sourceTree = "<group>"; };
 		7924B18F1D89DAE000589DB7 /* Error.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Error.swift; sourceTree = "<group>"; };
-		7924B1901D89DAE000589DB7 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
 		7924B1911D89DAE000589DB7 /* Options.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Options.swift; sourceTree = "<group>"; };
 		7924B1921D89DAE000589DB7 /* Parser.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Parser.swift; sourceTree = "<group>"; };
 		7924B1A81D89F79200589DB7 /* FPSStreamTask.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = FPSStreamTask.swift; sourceTree = "<group>"; };
+		792572401DF23BDA006A1526 /* LocalHelper.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = LocalHelper.swift; sourceTree = "<group>"; };
 		794C21FD1D58912A00EC49B8 /* DropboxHelper.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = DropboxHelper.swift; sourceTree = "<group>"; };
 		794C22091D5893F800EC49B8 /* SMB2Notification.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = SMB2Notification.swift; sourceTree = "<group>"; };
 		794C220D1D591A4B00EC49B8 /* SMB2QueryTypes.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = SMB2QueryTypes.swift; sourceTree = "<group>"; };
@@ -174,11 +170,9 @@
 		7924B18B1D89DAE000589DB7 /* AEXML */ = {
 			isa = PBXGroup;
 			children = (
-				7924B18C1D89DAE000589DB7 /* AEXML.h */,
 				7924B18D1D89DAE000589DB7 /* Document.swift */,
 				7924B18E1D89DAE000589DB7 /* Element.swift */,
 				7924B18F1D89DAE000589DB7 /* Error.swift */,
-				7924B1901D89DAE000589DB7 /* Info.plist */,
 				7924B1911D89DAE000589DB7 /* Options.swift */,
 				7924B1921D89DAE000589DB7 /* Parser.swift */,
 			);
@@ -225,6 +219,7 @@
 				799396941D48C02300086753 /* FileProvider.h */,
 				799396951D48C02300086753 /* FileProvider.swift */,
 				799396961D48C02300086753 /* LocalFileProvider.swift */,
+				792572401DF23BDA006A1526 /* LocalHelper.swift */,
 				7902C0851D61B56D00564440 /* RemoteSession.swift */,
 				7924B1A81D89F79200589DB7 /* FPSStreamTask.swift */,
 				799396971D48C02300086753 /* SMBClient.swift */,
@@ -261,7 +256,6 @@
 			isa = PBXHeadersBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
-				7924B1931D89DAE000589DB7 /* AEXML.h in Headers */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -269,7 +263,6 @@
 			isa = PBXHeadersBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
-				7924B1941D89DAE000589DB7 /* AEXML.h in Headers */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -277,7 +270,6 @@
 			isa = PBXHeadersBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
-				7924B1951D89DAE000589DB7 /* AEXML.h in Headers */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -382,7 +374,6 @@
 			isa = PBXResourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
-				7924B19F1D89DAE000589DB7 /* Info.plist in Resources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -390,7 +381,6 @@
 			isa = PBXResourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
-				7924B1A01D89DAE000589DB7 /* Info.plist in Resources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -398,7 +388,6 @@
 			isa = PBXResourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
-				7924B1A11D89DAE000589DB7 /* Info.plist in Resources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -412,6 +401,7 @@
 				799396B31D48C02300086753 /* LocalFileProvider.swift in Sources */,
 				799396D41D48C02300086753 /* SMB2Tree.swift in Sources */,
 				7924B1A21D89DAE000589DB7 /* Options.swift in Sources */,
+				792572411DF23BDA006A1526 /* LocalHelper.swift in Sources */,
 				7924B1991D89DAE000589DB7 /* Element.swift in Sources */,
 				799396C81D48C02300086753 /* SMB2IOCtl.swift in Sources */,
 				799396D71D48C02300086753 /* SMB2Types.swift in Sources */,
@@ -446,6 +436,7 @@
 				799396B41D48C02300086753 /* LocalFileProvider.swift in Sources */,
 				799396D51D48C02300086753 /* SMB2Tree.swift in Sources */,
 				7924B1A31D89DAE000589DB7 /* Options.swift in Sources */,
+				792572421DF23BDA006A1526 /* LocalHelper.swift in Sources */,
 				7924B1B01D89F7DE00589DB7 /* FPSStreamTask.swift in Sources */,
 				7924B19A1D89DAE000589DB7 /* Element.swift in Sources */,
 				799396C91D48C02300086753 /* SMB2IOCtl.swift in Sources */,
@@ -480,6 +471,7 @@
 				799396B51D48C02300086753 /* LocalFileProvider.swift in Sources */,
 				799396D61D48C02300086753 /* SMB2Tree.swift in Sources */,
 				7924B1A41D89DAE000589DB7 /* Options.swift in Sources */,
+				792572431DF23BDA006A1526 /* LocalHelper.swift in Sources */,
 				7924B1B11D89F7DF00589DB7 /* FPSStreamTask.swift in Sources */,
 				7924B19B1D89DAE000589DB7 /* Element.swift in Sources */,
 				799396CA1D48C02300086753 /* SMB2IOCtl.swift in Sources */,
@@ -513,7 +505,7 @@
 		799396601D48B7BF00086753 /* Debug */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
-				BUNDLE_VERSION_STRING = 0.6.1;
+				BUNDLE_VERSION_STRING = 0.7.0;
 				CLANG_WARN_BOOL_CONVERSION = YES;
 				CLANG_WARN_CONSTANT_CONVERSION = YES;
 				CLANG_WARN_EMPTY_BODY = YES;
@@ -543,7 +535,7 @@
 		799396611D48B7BF00086753 /* Release */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
-				BUNDLE_VERSION_STRING = 0.6.1;
+				BUNDLE_VERSION_STRING = 0.7.0;
 				CLANG_WARN_BOOL_CONVERSION = YES;
 				CLANG_WARN_CONSTANT_CONVERSION = YES;
 				CLANG_WARN_EMPTY_BODY = YES;
@@ -573,6 +565,7 @@
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
 				APPLICATION_EXTENSION_API_ONLY = YES;
+				BUNDLE_VERSION_STRING = 0.8.0;
 				CLANG_ANALYZER_NONNULL = YES;
 				CLANG_ENABLE_MODULES = YES;
 				CLANG_ENABLE_OBJC_ARC = YES;
@@ -609,7 +602,6 @@
 				IPHONEOS_DEPLOYMENT_TARGET = 8.0;
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks";
 				MTL_ENABLE_DEBUG_INFO = YES;
-				ONLY_ACTIVE_ARCH = YES;
 				PRODUCT_BUNDLE_IDENTIFIER = "com.mousavian.FileProvider-iOS";
 				PRODUCT_NAME = FileProvider;
 				SDKROOT = iphoneos;
@@ -626,6 +618,7 @@
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
 				APPLICATION_EXTENSION_API_ONLY = YES;
+				BUNDLE_VERSION_STRING = 0.8.0;
 				CLANG_ANALYZER_NONNULL = YES;
 				CLANG_ENABLE_MODULES = YES;
 				CLANG_ENABLE_OBJC_ARC = YES;
@@ -696,7 +689,6 @@
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
 				ENABLE_TESTABILITY = YES;
 				FRAMEWORK_VERSION = A;
-				GCC_C_LANGUAGE_STANDARD = gnu99;
 				GCC_DYNAMIC_NO_PIC = NO;
 				GCC_NO_COMMON_BLOCKS = YES;
 				GCC_PREPROCESSOR_DEFINITIONS = (
@@ -714,7 +706,6 @@
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/../Frameworks @loader_path/Frameworks";
 				MACOSX_DEPLOYMENT_TARGET = 10.10;
 				MTL_ENABLE_DEBUG_INFO = YES;
-				ONLY_ACTIVE_ARCH = YES;
 				PRODUCT_BUNDLE_IDENTIFIER = "com.mousavian.FileProvider-OSX";
 				PRODUCT_NAME = FileProvider;
 				SDKROOT = macosx;
@@ -753,7 +744,6 @@
 				ENABLE_NS_ASSERTIONS = NO;
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
 				FRAMEWORK_VERSION = A;
-				GCC_C_LANGUAGE_STANDARD = gnu99;
 				GCC_NO_COMMON_BLOCKS = YES;
 				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
 				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
@@ -802,7 +792,6 @@
 				DYLIB_INSTALL_NAME_BASE = "@rpath";
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
 				ENABLE_TESTABILITY = YES;
-				GCC_C_LANGUAGE_STANDARD = gnu99;
 				GCC_DYNAMIC_NO_PIC = NO;
 				GCC_NO_COMMON_BLOCKS = YES;
 				GCC_PREPROCESSOR_DEFINITIONS = (
@@ -819,7 +808,6 @@
 				INSTALL_PATH = "$(LOCAL_LIBRARY_DIR)/Frameworks";
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks";
 				MTL_ENABLE_DEBUG_INFO = YES;
-				ONLY_ACTIVE_ARCH = YES;
 				PRODUCT_BUNDLE_IDENTIFIER = "com.mousavian.FileProvider-tvOS";
 				PRODUCT_NAME = FileProvider;
 				SDKROOT = appletvos;
@@ -859,7 +847,6 @@
 				DYLIB_INSTALL_NAME_BASE = "@rpath";
 				ENABLE_NS_ASSERTIONS = NO;
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
-				GCC_C_LANGUAGE_STANDARD = gnu99;
 				GCC_NO_COMMON_BLOCKS = YES;
 				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
 				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
@@ -47,23 +47,39 @@ FileProvider supports both CocoaPods.

 Add this line to your pods file:

-	pod "FileProvider"
+```ruby
+pod "FileProvider"
+```
+
+Or add this to cartfile:
+
+```
+github "amosavian/FileProvider"
+```

 ### Git
 To have latest updates with ease, use this command on terminal to get a clone:

-	git clone https://github.com/amosavian/FileProvider FileProvider
-	
+```bash
+git clone https://github.com/amosavian/FileProvider
+```
+
 You can update your library using this command in FileProvider folder:

-	git pull
+```bash
+git pull
+```

 if you have a git based project, use this command in your projects directory to add this project as a submodule to your project:

-	git submodule add https://github.com/amosavian/FileProvider FileProvider
+```bash
+git submodule add https://github.com/amosavian/FileProvider
+```

 ### Manually
-Copy Source folder to your project and Voila!
+**First way:** Copy Source folder to your project and Voila!
+
+**Second way:** Drop FileProvider.xcodeproj to you Xcode workspace and add the framework to your Embeded Binaries in target.

 ## Usage

@@ -73,20 +89,26 @@ Each provider has a specific class which conforms to FileProvider protocol and s

 For LocalFileProvider if you want to deal with `Documents` folder

-	let documentsProvider = LocalFileProvider()
+```	swift
+let documentsProvider = LocalFileProvider()
+```

 is equal to:
-	    
-	let documentPath = NSSearchPathForDirectoriesInDomains(NSSearchPathDirectory.DocumentDirectory, NSSearchPathDomainMask.UserDomainMask, true);
-	let documentsURL = URL(fileURLWithPath: documentPath);
-	let documentsProvider = LocalFileProvider(baseURL: documentsURL)
+
+```	swift
+let documentPath = NSSearchPathForDirectoriesInDomains(NSSearchPathDirectory.DocumentDirectory, NSSearchPathDomainMask.UserDomainMask, true);
+let documentsURL = URL(fileURLWithPath: documentPath);
+let documentsProvider = LocalFileProvider(baseURL: documentsURL)
+```

 You can't change the base url later. and all paths are related to this base url by default.

 For remote file providers authentication may be necessary:

-	let credential = URLCredential(user: "user", password: "pass", persistence: .permanent)
-	let webdavProvider = WebDAVFileProvider(baseURL: URL(string: "http://www.example.com/dav")!, credential: credential)
+```	swift
+let credential = URLCredential(user: "user", password: "pass", persistence: .permanent)
+let webdavProvider = WebDAVFileProvider(baseURL: URL(string: "http://www.example.com/dav")!, credential: credential)
+```

 * In case you want to connect non-secure servers for WebDAV (http) in iOS 9+ / macOS 10.11+ you should disable App Transport Security (ATS) according to [this guide.](https://gist.github.com/mlynch/284699d676fe9ed0abfa)

@@ -104,40 +126,42 @@ It's simply three method which indicated whether the operation failed, succeed a

 Your class should conforms `FileProviderDelegate` class:

-	override func viewDidLoad() {
-		documentsProvider.delegate = self as FileProviderDelegate
-	}
+```swift
+override func viewDidLoad() {
+	documentsProvider.delegate = self as FileProviderDelegate
+}
 	
-	func fileproviderSucceed(_ fileProvider: FileProviderOperations, operation: FileOperation) {
-		switch operation {
-		case .copy(source: let source, destination: let dest):
-			print("\(source) copied to \(dest).")
-		case .remove(path: let path):
-			print("\(path) has been deleted.")
-		default:
-			break
-		}
+func fileproviderSucceed(_ fileProvider: FileProviderOperations, operation: FileOperation) {
+	switch operation {
+	case .copy(source: let source, destination: let dest):
+		print("\(source) copied to \(dest).")
+	case .remove(path: let path):
+		print("\(path) has been deleted.")
+	default:
+		print("\(operation.actionDescription) from \(operation.source!) to \(operation.destination) succeed")
 	}
-	
-    func fileproviderFailed(_ fileProvider: FileProviderOperations, operation: FileOperation) {
-    	switch operation {
-		case .copy(source: let source, destination: let dest):
-			print("copy of \(source) failed.")
-		case .remove(path: let path):
-			print("\(path) can't be deleted.")
-		default:
-			break
-		}
-    }
-	
-    func fileproviderProgress(_ fileProvider: FileProviderOperations, operation: FileOperation, progress: Float) {
-		switch operation {
-		case .copy(source: let source, destination: let dest):
-			print("Copy\(source) to \(dest): \(progress * 100) completed.")
-		default:
-			break
-		}
+}
+
+func fileproviderFailed(_ fileProvider: FileProviderOperations, operation: FileOperation) {
+    switch operation {
+	case .copy(source: let source, destination: let dest):
+		print("copy of \(source) failed.")
+	case .remove:
+		print("file can't be deleted.")
+	default:
+		print("\(operation.actionDescription) from \(operation.source!) to \(operation.destination) failed")
 	}
+}
+	
+func fileproviderProgress(_ fileProvider: FileProviderOperations, operation: FileOperation, progress: Float) {
+	switch operation {
+	case .copy(source: let source, destination: let dest):
+		print("Copy\(source) to \(dest): \(progress * 100) completed.")
+	default:
+		break
+	}
+}
+```

 **Note:** `fileproviderProgress()` delegate method is not called by `LocalFileProvider` currently. 

@@ -159,42 +183,50 @@ There is a `FileObject` class which holds file attributes like size and creation

 For a single file:

-	documentsProvider.attributesOfItem(path: "/file.txt", completionHandler: {
-	    (attributes: LocalFileObject?, error: ErrorType?) -> Void in
-		if let attributes = attributes {
-			print("File Size: \(attributes.size)")
-			print("Creation Date: \(attributes.createdDate)")
-			print("Modification Date: \(attributes.modifiedDate)")
-			print("Is Read Only: \(attributes.isReadOnly)")
-		}
-	})
+```swift
+documentsProvider.attributesOfItem(path: "/file.txt", completionHandler: {
+	attributes, error in
+	if let attributes = attributes {
+		print("File Size: \(attributes.size)")
+		print("Creation Date: \(attributes.creationDate)")
+		print("Modification Date: \(attributes.modifiedDate)")
+		print("Is Read Only: \(attributes.isReadOnly)")
+	}
+})
+```

 To get list of files in a directory:

-	documentsProvider.contentsOfDirectory(path: "/", 	completionHandler: {
-	    (contents: [LocalFileObject], error: ErrorType?) -> Void in
-		for file in contents {
-			print("Name: \(attributes.name)")
-			print("Size: \(attributes.size)")
-			print("Creation Date: \(attributes.createdDate)")
-			print("Modification Date: \(attributes.modifiedDate)")
-		}
-	})
+```swift
+documentsProvider.contentsOfDirectory(path: "/", completionHandler: {
+	contents, error in
+	for file in contents {
+		print("Name: \(attributes.name)")
+		print("Size: \(attributes.size)")
+		print("Creation Date: \(attributes.creationDate)")
+		print("Modification Date: \(attributes.modifiedDate)")
+	}
+})
+```

 To get size of strage and used/free space:

-	func storageProperties(completionHandler: {(total: Int64, used: Int64) -> Void in
-	    print("Total Storage Space: \(total)")
-	    print("Used Space: \(used)")
-	    print("Free Space: \(total - used)")
-	})
+```swift
+func storageProperties(completionHandler: { total, used in
+	print("Total Storage Space: \(total)")
+	print("Used Space: \(used)")
+	print("Free Space: \(total - used)")
+})
+```
 	
 * if this function is unavailable on provider or an error has been occurred, total space will be reported `-1` and used space `0`

 ### Change current directory

-	documentsProvider.currentPath = "/New Folder"
-	// now path is ~/Documents/New Folder
+```swift
+documentsProvider.currentPath = "/New Folder"
+// now path is ~/Documents/New Folder
+```
 	
 You can then pass "" (empty string) to `contentsOfDirectory` method to list files in current directory.

@@ -202,60 +234,75 @@ You can then pass "" (empty string) to `contentsOfDirectory` method to list file

 Creating new directory:

-	documentsProvider.create(folder: "new folder", at: "/", completionHandler: nil)
+```swift
+documentsProvider.create(folder: "new folder", at: "/", completionHandler: nil)
+```

-Creating new file from data stream:
+Creating new file from data:

-	let data = "hello world!".data(encoding: String.encoding.utf8)
-	let file = FileObject(name: "old.txt", createdDate: Date(), modifiedDate: Date(), isHidden: false, isReadOnly: true)
-	documentsProvider.create(file: file, at: "/", contents: data, completionHandler: nil)
+```swift
+let data = "hello world!".data(encoding: .utf8)
+documentsProvider.create(file: "newFile.txt", at: "/", contents: data, completionHandler: nil)
+```

 ### Copy and Move/Rename Files

 Copy file old.txt to new.txt in current path:

-	documentsProvider.copyItem(path: "new folder/old.txt", to: "new.txt", overwrite: false, completionHandler: nil)
+```swift
+documentsProvider.copyItem(path: "new folder/old.txt", to: "new.txt", overwrite: false, completionHandler: nil)
+```

 Move file old.txt to new.txt in current path:

-	documentsProvider.moveItem(path: "new folder/old.txt", to: "new.txt", overwrite: false, completionHandler: nil)
+```swift
+documentsProvider.moveItem(path: "new folder/old.txt", to: "new.txt", overwrite: false, completionHandler: nil)
+```

-**Note:** To have a consistent behaviour, create intermediate directories first if necessary.
+**Note:** To have a consistent behavior, create intermediate directories first if necessary.

 ### Delete Files

-	documentsProvider.removeItem(path: "new.txt", completionHandler: nil)
+```swift
+documentsProvider.removeItem(path: "new.txt", completionHandler: nil)
+```

-***Caution:*** This method will delete directories with all it's content recursively.
+***Caution:*** This method will delete directories with all it's contents recursively.

-### Retrieve Content of File
+### Fetching Contents of File

 There is two method for this purpose, one of them loads entire file into NSData and another can load a portion of file.

-	documentsProvider.contents(path: "old.txt", completionHandler: {
-		(contents: Data?, error: ErrorType?) -> Void
-		if let contents = contents {
-			print(String(data: contents, encoding: String.encoding.utf8)) // "hello world!"
-		}
-	})
+```swift
+documentsProvider.contents(path: "old.txt", completionHandler: {
+	contents, error in
+	if let contents = contents {
+		print(String(data: contents, encoding: .utf8)) // "hello world!"
+	}
+})
+```
 	
 If you want to retrieve a portion of file you can use `contents` method with offset and length arguments. Please note first byte of file has offset: 0.

-	documentsProvider.contents(path: "old.txt", offset: 2, length: 5, completionHandler: {
-		(contents: Data?, error: ErrorType?) -> Void
-		if let contents = contents {
-			print(String(data: contents, encoding: String.encoding.utf8)) // "llo w"
-		}
-	})
+```swift
+documentsProvider.contents(path: "old.txt", offset: 2, length: 5, completionHandler: {
+	contents, error in
+	if let contents = contents {
+		print(String(data: contents, encoding: .utf8)) // "llo w"
+	}
+})
+```

 ### Write Data To Files

-	let data = "What's up Newyork!".data(encoding: String.encoding.utf8)
-	documentsProvider.writeContents(path: "old.txt", content: data, atomically: true, completionHandler: nil)
+```swift
+let data = "What's up Newyork!".data(encoding: .utf8)
+documentsProvider.writeContents(path: "old.txt", content: data, atomically: true, completionHandler: nil)
+```

 ### Operation Handle

-Creating/Copying/Deleting functions return a `OperationHandle` for remote operations. It provides progress and a `.cancel()` method which allows you to cancel operation in midst.
+Creating/Copying/Deleting functions return a `OperationHandle` for remote operations. It provides operation type, progress and a `.cancel()` method which allows you to cancel operation in midst.

 It's not supported by native `(NS)FileManager` so `LocalFileProvider`, but this functionality will be added to future `PosixFileProvider` class.

@@ -263,13 +310,16 @@ It's not supported by native `(NS)FileManager` so `LocalFileProvider`, but this

 You can monitor updates in some file system (Local and SMB2), there is three methods in supporting provider you can use to register a handler, to unregister and to check whether it's being monitored or not. It's useful to find out when new files added or removed from directory and update user interface. The handler will be dispatched to main threads to avoid UI bugs with a 0.25 sec delay.

-	documentsProvider.registerNotifcation(path: provider.currentPath)
-	{
-		// calling functions to update UI 
-	}
+```swift
+// to register a new notification handler
+documentsProvider.registerNotifcation(path: provider.currentPath)
+{
+	// calling functions to update UI 
+}
 	
-	// To discontinue monitoring folders:
-	documentsProvider.unregisterNotifcation(path: provider.currentPath)
+// To discontinue monitoring folders:
+documentsProvider.unregisterNotifcation(path: provider.currentPath)
+```

 * **Please note** in LocalFileProvider it will also monitor changes in subfolders. This behaviour can varies according to file system specification.

@@ -13,7 +13,7 @@ import CoreGraphics
 // Because this class uses NSURLSession, it's necessary to disable App Transport Security
 // in case of using this class with unencrypted HTTP connection.

-open class DropboxFileProvider: NSObject,  FileProviderBasic {
+open class DropboxFileProvider: NSObject,  FileProviderBasicRemote {
    open static let type: String = "WebDAV"
    open let isPathRelative: Bool = true
    open let baseURL: URL?
@@ -25,24 +25,31 @@ open class DropboxFileProvider: NSObject,  FileProviderBasic {
    }
    open weak var delegate: FileProviderDelegate?
    open let credential: URLCredential?
-    
+    open private(set) var cache: URLCache?
+    public var useCache: Bool = false
+    public var validatingCache: Bool = true
+   
    fileprivate var _session: URLSession?
    fileprivate var sessionDelegate: SessionDelegate?
-    internal var session: URLSession {
+    public var session: URLSession {
        if _session == nil {
            self.sessionDelegate = SessionDelegate(fileProvider: self, credential: credential)
            let queue = OperationQueue()
            //queue.underlyingQueue = dispatch_queue
-            _session = URLSession(configuration: URLSessionConfiguration.default, delegate: sessionDelegate as URLSessionDelegate?, delegateQueue: queue)
+            let config = URLSessionConfiguration.default
+            config.urlCache = cache
+            config.requestCachePolicy = .returnCacheDataElseLoad
+            _session = URLSession(configuration: config, delegate: sessionDelegate as URLSessionDelegate?, delegateQueue: queue)
        }
        return _session!
    }
    
-    public init? (credential: URLCredential?) {
+    public init? (credential: URLCredential?, cache: URLCache? = nil) {
        self.baseURL = nil
        dispatch_queue = DispatchQueue(label: "FileProvider.\(DropboxFileProvider.type)", attributes: DispatchQueue.Attributes.concurrent)
        //let url = baseURL.uw_absoluteString
        self.credential = credential
+        self.cache = cache
    }
    
    deinit {
@@ -106,8 +113,9 @@ extension DropboxFileProvider: FileProviderOperations {
        return doOperation(.create(path: path), completionHandler: completionHandler)
    }
    
-    public func create(file fileAttribs: FileObject, at path: String, contents data: Data?, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
-        return self.writeContents(path: path, contents: data ?? Data(), completionHandler: completionHandler)
+    public func create(file fileName: String, at path: String, contents data: Data?, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
+        let filePath = (path as NSString).appendingPathComponent(fileName)
+        return self.writeContents(path: filePath, contents: data ?? Data(), completionHandler: completionHandler)
    }
    
    public func moveItem(path: String, to toPath: String, overwrite: Bool = false, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
@@ -127,25 +135,18 @@ extension DropboxFileProvider: FileProviderOperations {
            return nil
        }
        let url: String
-        var path: String?, fromPath: String?, toPath: String?
+        guard let sourcePath = operation.source else { return nil }
+        let destPath = operation.destination
        switch operation {
-        case .create(path: let p):
+        case .create:
            url = "https://api.dropboxapi.com/2/files/create_folder"
-            path = p
-        case .copy(source: let fp, destination: let tp):
+        case .copy:
            url = "https://api.dropboxapi.com/2/files/copy"
-            fromPath = fp
-            toPath = tp
-        case .move(source: let fp, destination: let tp):
+        case .move:
            url = "https://api.dropboxapi.com/2/files/move"
-            fromPath = fp
-            toPath = tp
-        case .remove(path: let p):
+        case .remove:
            url = "https://api.dropboxapi.com/2/files/delete"
-            path = p
-        case .modify(path: _):
-            return nil
-        case .link(link: _, target: _):
+        default: // modify, link, fetch
            return nil
        }
        var request = URLRequest(url: URL(string: url)!)
@@ -153,24 +154,29 @@ extension DropboxFileProvider: FileProviderOperations {
        request.setValue("Bearer \(credential?.password ?? "")", forHTTPHeaderField: "Authorization")
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        var requestDictionary = [String: AnyObject]()
-        requestDictionary["path"] = correctPath(path) as NSString?
-        requestDictionary["from_path"] = correctPath(fromPath) as NSString?
-        requestDictionary["to_path"] = correctPath(toPath) as NSString?
+        if let dest = correctPath(destPath) as NSString? {
+            requestDictionary["from_path"] = correctPath(sourcePath) as NSString?
+            requestDictionary["to_path"] = dest
+        } else {
+            requestDictionary["path"] = correctPath(sourcePath) as NSString?
+        }
        request.httpBody = dictionaryToJSON(requestDictionary)?.data(using: .utf8)
        let task = session.dataTask(with: request, completionHandler: { (data, response, error) in
            var dbError: FileProviderDropboxError?
            if let response = response as? HTTPURLResponse, response.statusCode >= 300, let code = FileProviderHTTPErrorCode(rawValue: response.statusCode) {
-                 dbError = FileProviderDropboxError(code: code, path: path ?? fromPath ?? "", errorDescription: String(data: data ?? Data(), encoding: .utf8))
+                 dbError = FileProviderDropboxError(code: code, path: sourcePath, errorDescription: String(data: data ?? Data(), encoding: .utf8))
            }
            completionHandler?(dbError ?? error)
            self.delegateNotify(operation, error: dbError ?? error)
-        }) 
+        })
+        task.taskDescription = operation.json
        task.resume()
-        return RemoteOperationHandle(tasks: [task])
+        return RemoteOperationHandle(operationType: operation, tasks: [task])
    }
    
    public func copyItem(localFile: URL, to toPath: String, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
-        guard fileOperationDelegate?.fileProvider(self, shouldDoOperation: .copy(source: localFile.absoluteString, destination: toPath)) ?? true == true else {
+        let opType = FileOperationType.copy(source: localFile.absoluteString, destination: toPath)
+        guard fileOperationDelegate?.fileProvider(self, shouldDoOperation: opType) ?? true == true else {
            return nil
        }
        guard let data = try? Data(contentsOf: localFile) else {
@@ -178,24 +184,26 @@ extension DropboxFileProvider: FileProviderOperations {
            completionHandler?(error)
            return nil
        }
-        return upload_simple(toPath, data: data, overwrite: true, operation: .copy(source: localFile.absoluteString, destination: toPath), completionHandler: completionHandler)
+        return upload_simple(toPath, data: data, overwrite: true, operation: opType, completionHandler: completionHandler)
    }
    
    public func copyItem(path: String, toLocalURL destURL: URL, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
-        guard fileOperationDelegate?.fileProvider(self, shouldDoOperation: .copy(source: path, destination: destURL.absoluteString)) ?? true == true else {
+        let opType = FileOperationType.copy(source: path, destination: destURL.absoluteString)
+        guard fileOperationDelegate?.fileProvider(self, shouldDoOperation: opType) ?? true == true else {
            return nil
        }
        let url = URL(string: "https://content.dropboxapi.com/2/files/download")!
        var request = URLRequest(url: url)
        request.httpMethod = "GET"
        request.setValue("Bearer \(credential?.password ?? "")", forHTTPHeaderField: "Authorization")
-        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
-        let requestDictionary = ["path": path as NSString]
-        request.setValue(dictionaryToJSON(requestDictionary), forHTTPHeaderField: "Dropbox-API-Arg")
+        let requestDictionary = ["path": path]
+        let requestJson = dictionaryToJSON(requestDictionary as [String : AnyObject]) ?? ""
+        request.setValue(requestJson, forHTTPHeaderField: "Dropbox-API-Arg")
        let task = session.downloadTask(with: request, completionHandler: { (cacheURL, response, error) in
            guard let cacheURL = cacheURL, let httpResponse = response as? HTTPURLResponse , httpResponse.statusCode < 300 else {
                let code = FileProviderHTTPErrorCode(rawValue: (response as? HTTPURLResponse)?.statusCode ?? -1)
-                let dbError: FileProviderDropboxError? = code != nil ? FileProviderDropboxError(code: code!, path: path, errorDescription: nil) : nil
+                let errorData : Data? = nil //Data(contentsOf:cacheURL) // TODO: Figure out how to get error response data for the error description
+                let dbError : FileProviderDropboxError? = code != nil ? FileProviderDropboxError(code: code!, path: path, errorDescription: String(data: errorData ?? Data(), encoding: .utf8)) : nil
                completionHandler?(dbError ?? error)
                return
            }
@@ -206,9 +214,9 @@ extension DropboxFileProvider: FileProviderOperations {
                completionHandler?(e)
            }
        })
-        task.taskDescription = dictionaryToJSON(["type": "Copy" as NSString, "source": path as NSString, "dest": destURL.absoluteString as NSString])
+        task.taskDescription = opType.json
        task.resume()
-        return RemoteOperationHandle(tasks: [task])
+        return RemoteOperationHandle(operationType: opType, tasks: [task])
    }
 }

@@ -218,6 +226,7 @@ extension DropboxFileProvider: FileProviderReadWrite {
    }
    
    public func contents(path: String, offset: Int64, length: Int, completionHandler: @escaping ((_ contents: Data?, _ error: Error?) -> Void)) -> OperationHandle? {
+        let opType = FileOperationType.fetch(path: path)
        let url = URL(string: "https://content.dropboxapi.com/2/files/download")!
        var request = URLRequest(url: url)
        request.httpMethod = "GET"
@@ -227,7 +236,7 @@ extension DropboxFileProvider: FileProviderReadWrite {
        } else if offset > 0 && length < 0 {
            request.setValue("bytes=\(offset)-", forHTTPHeaderField: "Range")
        }
-        let requestDictionary = ["path": path]
+        let requestDictionary = ["path": correctPath(path)! as NSString]
        request.setValue(dictionaryToJSON(requestDictionary as [String : AnyObject]), forHTTPHeaderField: "Dropbox-API-Arg")
        let task = session.dataTask(with: request, completionHandler: { (data, response, error) in
            var dbError: FileProviderDropboxError?
@@ -237,16 +246,18 @@ extension DropboxFileProvider: FileProviderReadWrite {
            let filedata = dbError ?? error == nil ? data : nil
            completionHandler(filedata, dbError ?? error)
        })
+        task.taskDescription = opType.json
        task.resume()
-        return RemoteOperationHandle(tasks: [task])
+        return RemoteOperationHandle(operationType: opType, tasks: [task])
    }
    
    public func writeContents(path: String, contents data: Data, atomically: Bool = false, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
-        guard fileOperationDelegate?.fileProvider(self, shouldDoOperation: .modify(path: path)) ?? true == true else {
+        let opType = FileOperationType.modify(path: path)
+        guard fileOperationDelegate?.fileProvider(self, shouldDoOperation: opType) ?? true == true else {
            return nil
        }
        // FIXME: remove 150MB restriction
-        return upload_simple(path, data: data, overwrite: true, operation: .modify(path: path), completionHandler: completionHandler)
+        return upload_simple(path, data: data, overwrite: true, operation: opType, completionHandler: completionHandler)
    }
    
    public func searchFiles(path: String, recursive: Bool, query: String, foundItemHandler: ((FileObject) -> Void)?, completionHandler: @escaping ((_ files: [FileObject], _ error: Error?) -> Void)) {
@@ -272,7 +283,65 @@ extension DropboxFileProvider: FileProviderReadWrite {
        NotImplemented()
    }
    
-    // TODO: Implement /copy_reference, /get_temporary_link, /save_url, /get_account & /get_current_account
+    // TODO: Implement /copy_reference, /get_account & /get_current_account
+}
+
+extension DropboxFileProvider {
+    open func temporaryLink(to path: String, completionHandler: @escaping ((_ link: URL?, _ attribute: DropboxFileObject?, _ error: Error?) -> Void)) {
+        let url = URL(string: "https://api.dropboxapi.com/2/files/get_temporary_link")!
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.setValue("Bearer \(credential?.password ?? "")", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        let requestDictionary = ["path": correctPath(path)! as NSString]
+        request.httpBody = dictionaryToJSON(requestDictionary)?.data(using: .utf8)
+        let task = session.dataTask(with: request, completionHandler: { (data, response, error) in
+            var dbError: FileProviderDropboxError?
+            var link: URL?
+            var fileObject: DropboxFileObject?
+            if let response = response as? HTTPURLResponse {
+                let code = FileProviderHTTPErrorCode(rawValue: response.statusCode)
+                dbError = code != nil ? FileProviderDropboxError(code: code!, path: path, errorDescription: String(data: data ?? Data(), encoding: .utf8)) : nil
+                if let data = data, let jsonStr = String(data: data, encoding: .utf8), let json = jsonToDictionary(jsonStr) {
+                    if let linkStr = json["link"] as? String {
+                        link = URL(string: linkStr)
+                    }
+                    if let attribDic = json["metadata"] as? [String: AnyObject] {
+                        fileObject = self.mapToFileObject(attribDic)
+                    }
+                }
+            }
+            completionHandler(link, fileObject, dbError ?? error)
+        })
+        task.resume()
+    }
+    
+    open func copyItem(path: String, toRemoteURL destURL: URL, completionHandler: @escaping ((_ jobId: String?, _ attribute: DropboxFileObject?, _ error: Error?) -> Void)) {
+        let url = URL(string: "https://api.dropboxapi.com/2/files/save_url")!
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.setValue("Bearer \(credential?.password ?? "")", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        let requestDictionary = ["path": correctPath(path)! as NSString, "url" : destURL.absoluteString as NSString]
+        request.httpBody = dictionaryToJSON(requestDictionary)?.data(using: .utf8)
+        let task = session.dataTask(with: request, completionHandler: { (data, response, error) in
+            var dbError: FileProviderDropboxError?
+            var jobId: String?
+            var fileObject: DropboxFileObject?
+            if let response = response as? HTTPURLResponse {
+                let code = FileProviderHTTPErrorCode(rawValue: response.statusCode)
+                dbError = code != nil ? FileProviderDropboxError(code: code!, path: path, errorDescription: String(data: data ?? Data(), encoding: .utf8)) : nil
+                if let data = data, let jsonStr = String(data: data, encoding: .utf8), let json = jsonToDictionary(jsonStr) {
+                    jobId = json["async_job_id"] as? String
+                    if let attribDic = json["metadata"] as? [String: AnyObject] {
+                        fileObject = self.mapToFileObject(attribDic)
+                    }
+                }
+            }
+            completionHandler(jobId, fileObject, dbError ?? error)
+        })
+        task.resume()
+    }
 }

 extension DropboxFileProvider: ExtendedFileProvider {
@@ -315,7 +384,7 @@ extension DropboxFileProvider: ExtendedFileProvider {
        requestDictionary["format"] = "jpeg" as NSString
        requestDictionary["size"] = "w\(Int(dimension.width))h\(Int(dimension.height))" as NSString
        request.setValue(dictionaryToJSON(requestDictionary), forHTTPHeaderField: "Dropbox-API-Arg")
-        self.session.dataTask(with: request, completionHandler: { (data, response, error) in
+        let task = self.session.dataTask(with: request, completionHandler: { (data, response, error) in
            var image: ImageClass? = nil
            if let r = response as? HTTPURLResponse, let result = r.allHeaderFields["Dropbox-API-Result"] as? String, let jsonResult = jsonToDictionary(result) {
                if jsonResult["error"] != nil {
@@ -326,7 +395,8 @@ extension DropboxFileProvider: ExtendedFileProvider {
                image = ImageClass(data: data)
            }
            completionHandler(image, error)
-        }) 
+        })
+        task.resume()
    }
    
    public func propertiesOfFile(path: String, completionHandler: @escaping ((_ propertiesDictionary: [String : Any], _ keys: [String], _ error: Error?) -> Void)) {
@@ -334,4 +404,14 @@ extension DropboxFileProvider: ExtendedFileProvider {
    }
 }

-extension DropboxFileProvider: FileProvider {}
+extension DropboxFileProvider: FileProvider {
+    open func copy(with zone: NSZone? = nil) -> Any {
+        let copy = DropboxFileProvider(credential: self.credential, cache: self.cache)!
+        copy.currentPath = self.currentPath
+        copy.delegate = self.delegate
+        copy.fileOperationDelegate = self.fileOperationDelegate
+        copy.useCache = self.useCache
+        copy.validatingCache = self.validatingCache
+        return copy
+    }
+}
@@ -19,21 +19,39 @@ public struct FileProviderDropboxError: Error, CustomStringConvertible {
 }

 public final class DropboxFileObject: FileObject {
-    public let serverTime: Date?
-    public let id: String?
-    public let rev: String?
-    
-    // codebeat:disable[ARITY]
-    public init(name: String, path: String, size: Int64 = -1, serverTime: Date? = nil, modifiedDate: Date? = nil, fileType: FileType = .regular, isHidden: Bool = false, isReadOnly: Bool = false, id: String? = nil, rev: String? = nil) {
-        self.serverTime = serverTime
-        self.id = id
-        self.rev = rev
-        super.init(absoluteURL: URL(string: path), name: name, path: path, size: size, createdDate: nil, modifiedDate: modifiedDate, fileType: fileType, isHidden: isHidden, isReadOnly: isReadOnly)
+    internal init(name: String, path: String) {
+        super.init(absoluteURL: URL(string: path), name: name, path: path)
+    }
+    
+    open internal(set) var serverTime: Date? {
+        get {
+            return allValues["NSURLServerDateKey"] as? Date
+        }
+        set {
+            allValues["NSURLServerDateKey"] = newValue
+        }
+    }
+    
+    open internal(set) var id: String? {
+        get {
+            return allValues["NSURLDropboxDocumentIdentifyKey"] as? String
+        }
+        set {
+            allValues["NSURLDropboxDocumentIdentifyKey"] = newValue
+        }
+    }
+    
+    open internal(set) var rev: String? {
+        get {
+            return allValues[URLResourceKey.generationIdentifierKey.rawValue] as? String
+        }
+        set {
+            allValues[URLResourceKey.generationIdentifierKey.rawValue] = newValue
+        }
    }
-    // codebeat:enable[ARITY]
 }

-// codebeat:disable[ARITY]
+ // codebeat:disable[ARITY]
 internal extension DropboxFileProvider {
    func list(_ path: String, cursor: String? = nil, prevContents: [DropboxFileObject] = [], recursive: Bool = false, completionHandler: @escaping ((_ contents: [FileObject], _ cursor: String?, _ error: Error?) -> Void)) {
        var requestDictionary = [String: AnyObject]()
@@ -74,7 +92,8 @@ internal extension DropboxFileProvider {
                }
            }
            completionHandler(files, nil, responseError ?? error)
-        }) 
+        })
+        task.taskDescription = FileOperationType.fetch(path: path).json
        task.resume()
    }
    
@@ -102,24 +121,9 @@ internal extension DropboxFileProvider {
            completionHandler?(responseError ?? error)
            self.delegateNotify(.create(path: targetPath), error: responseError ?? error)
        }) 
-        var dic: [String: AnyObject] = ["type": operation.description as NSString]
-        switch operation {
-        case .create(path: let s):
-            dic["source"] = s as NSString
-        case .copy(source: let s, destination: let d):
-            dic["source"] = s as NSString
-            dic["dest"] = d as NSString
-        case .modify(path: let s):
-            dic["source"] = s as NSString
-        case .move(source: let s, destination: let d):
-            dic["source"] = s as NSString
-            dic["dest"] = d as NSString
-        default:
-            break
-        }
-        task.taskDescription = dictionaryToJSON(dic)
+        task.taskDescription = operation.json
        task.resume()
-        return RemoteOperationHandle(tasks: [task])
+        return RemoteOperationHandle(operationType: operation, tasks: [task])
    }
    
    func search(_ startPath: String = "", query: String, start: Int = 0, maxResultPerPage: Int = 25, maxResults: Int = -1, foundItem:@escaping ((_ file: DropboxFileObject) -> Void), completionHandler: @escaping ((_ error: Error?) -> Void)) {
@@ -172,14 +176,15 @@ internal extension DropboxFileProvider {
    func mapToFileObject(_ json: [String: AnyObject]) -> DropboxFileObject? {
        guard let name = json["name"] as? String else { return nil }
        guard let path = json["path_display"] as? String else { return nil }
-        let size = (json["size"] as? NSNumber)?.int64Value ?? -1
-        let serverTime = resolve(dateString: json["server_modified"] as? String ?? "")
-        let modifiedDate = resolve(dateString: json["client_modified"] as? String ?? "")
-        let isDirectory = (json[".tag"] as? String) == "folder"
-        let isReadonly = (json["sharing_info"]?["read_only"] as? NSNumber)?.boolValue ?? false
-        let id = json["id"] as? String
-        let rev = json["id"] as? String
-        return DropboxFileObject(name: name, path: path, size: size, serverTime: serverTime, modifiedDate: modifiedDate, fileType: isDirectory ? .directory : .regular, isReadOnly: isReadonly, id: id, rev: rev)
+        let fileObject = DropboxFileObject(name: name, path: path)
+        fileObject.size = (json["size"] as? NSNumber)?.int64Value ?? -1
+        fileObject.serverTime = resolve(dateString: json["server_modified"] as? String ?? "")
+        fileObject.modifiedDate = resolve(dateString: json["client_modified"] as? String ?? "")
+        fileObject.fileType = (json[".tag"] as? String) == "folder" ? .directory : .regular
+        fileObject.isReadOnly = (json["sharing_info"]?["read_only"] as? NSNumber)?.boolValue ?? false
+        fileObject.id = json["id"] as? String
+        fileObject.rev = json["id"] as? String
+        return fileObject
    }
    
    func delegateNotify(_ operation: FileOperationType, error: Error?) {
@@ -15,85 +15,6 @@ import Cocoa
 public typealias ImageClass = NSImage
 #endif

-public enum FileType: String {
-    case directory
-    case regular
-    case symbolicLink
-    case socket
-    case characterSpecial
-    case blockSpecial
-    case namedPipe
-    case unknown
-    
-    public init(urlResourceTypeValue: URLFileResourceType) {
-        switch urlResourceTypeValue {
-        case URLFileResourceType.namedPipe: self = .namedPipe
-        case URLFileResourceType.characterSpecial: self = .characterSpecial
-        case URLFileResourceType.directory: self = .directory
-        case URLFileResourceType.blockSpecial: self = .blockSpecial
-        case URLFileResourceType.regular: self = .regular
-        case URLFileResourceType.symbolicLink: self = .symbolicLink
-        case URLFileResourceType.socket: self = .socket
-        case URLFileResourceType.unknown: self = .unknown
-        default: self = .unknown
-        }
-    }
-    
-    public init(fileTypeValue: FileAttributeType) {
-        switch fileTypeValue {
-        case FileAttributeType.typeCharacterSpecial: self = .characterSpecial
-        case FileAttributeType.typeDirectory: self = .directory
-        case FileAttributeType.typeBlockSpecial: self = .blockSpecial
-        case FileAttributeType.typeRegular: self = .regular
-        case FileAttributeType.typeSymbolicLink: self = .symbolicLink
-        case FileAttributeType.typeSocket: self = .socket
-        case FileAttributeType.typeUnknown: self = .unknown
-        default: self = .unknown
-        }
-    }
-}
-
-public protocol FoundationErrorEnum {
-    init? (rawValue: Int)
-    var rawValue: Int { get }
-}
-
-extension URLError.Code: FoundationErrorEnum {}
-extension CocoaError.Code: FoundationErrorEnum {}
-
-open class FileObject {
-    open let absoluteURL: URL?
-    open let name: String
-    open let path: String
-    open let size: Int64
-    open let createdDate: Date?
-    open let modifiedDate: Date?
-    open let fileType: FileType
-    open let isHidden: Bool
-    open let isReadOnly: Bool
-    
-    public init(absoluteURL: URL? = nil, name: String, path: String, size: Int64 = -1, createdDate: Date? = nil, modifiedDate: Date? = nil, fileType: FileType = .regular, isHidden: Bool = false, isReadOnly: Bool = false) {
-        self.absoluteURL = absoluteURL
-        self.name = name
-        self.path = path
-        self.size = size
-        self.createdDate = createdDate
-        self.modifiedDate = modifiedDate
-        self.fileType = fileType
-        self.isHidden = isHidden
-        self.isReadOnly = isReadOnly
-    }
-    
-    open var isDirectory: Bool {
-        return self.fileType == .directory
-    }
-    
-    open var isSymLink: Bool {
-        return self.fileType == .symbolicLink
-    }
-}
-
-
 public typealias SimpleCompletionHandler = ((_ error: Error?) -> Void)?

 public protocol FileProviderBasic: class {
@@ -114,13 +35,68 @@ public protocol FileProviderBasic: class {
    func storageProperties(completionHandler: @escaping ((_ total: Int64, _ used: Int64) -> Void))
 }

+public protocol FileProviderBasicRemote: FileProviderBasic {
+    var session: URLSession { get }
+    var cache: URLCache? { get }
+    var useCache: Bool { get set }
+    var validatingCache: Bool { get set }
+}
+
+internal extension FileProviderBasicRemote {
+    func returnCachedDate(with request: URLRequest, validatingCache: Bool, completionHandler: @escaping (Data?, URLResponse?, Error?) -> Swift.Void) -> Bool {
+        guard let cache = self.cache else { return false }
+        if let response = cache.cachedResponse(for: request) {
+            var validatedCache = !validatingCache
+            let lastModifiedDate = (response.response as? HTTPURLResponse)?.allHeaderFields["Last-Modified"] as? String
+            let eTag = (response.response as? HTTPURLResponse)?.allHeaderFields["ETag"] as? String
+            if lastModifiedDate == nil && eTag == nil, validatingCache {
+                var validateRequest = request
+                validateRequest.httpMethod = "HEAD"
+                let group = DispatchGroup()
+                group.enter()
+                self.session.dataTask(with: validateRequest, completionHandler: { (_, response, e) in
+                    if let httpResponse = response as? HTTPURLResponse {
+                        let currentETag = httpResponse.allHeaderFields["ETag"] as? String
+                        let currentLastModifiedDate = httpResponse.allHeaderFields["ETag"] as? String ?? "nonvalidetag"
+                        validatedCache = (eTag != nil && currentETag == eTag)
+                            || (lastModifiedDate != nil && currentLastModifiedDate == lastModifiedDate)
+                    }
+                    group.leave()
+                }).resume()
+                _ = group.wait(timeout: DispatchTime.now() + self.session.configuration.timeoutIntervalForRequest)
+            }
+            if validatedCache {
+                completionHandler(response.data, response.response, nil)
+                return true
+            }
+        }
+        return false
+    }
+    
+    func runDataTask(with request: URLRequest, operationHandle: RemoteOperationHandle? = nil, completionHandler: @escaping (Data?, URLResponse?, Error?) -> Swift.Void) {
+        let useCache = self.useCache
+        let validatingCache = self.validatingCache
+        dispatch_queue.async {
+            if useCache {
+                if self.returnCachedDate(with: request, validatingCache: validatingCache, completionHandler: completionHandler) {
+                    return
+                }
+            }
+            let task = self.session.dataTask(with: request, completionHandler: completionHandler)
+            task.taskDescription = operationHandle?.operationType.json
+            operationHandle?.add(task: task)
+            task.resume()
+        }
+    }
+}
+
 public protocol FileProviderOperations: FileProviderBasic {
    var fileOperationDelegate : FileOperationDelegate? { get set }
    
    @discardableResult
    func create(folder: String, at: String, completionHandler: SimpleCompletionHandler) -> OperationHandle?
    @discardableResult
-    func create(file: FileObject, at: String, contents data: Data?, completionHandler: SimpleCompletionHandler) -> OperationHandle?
+    func create(file: String, at: String, contents data: Data?, completionHandler: SimpleCompletionHandler) -> OperationHandle?
    @discardableResult
    func moveItem(path: String, to: String, overwrite: Bool, completionHandler: SimpleCompletionHandler) -> OperationHandle?
    @discardableResult
@@ -151,13 +127,12 @@ public protocol FileProviderMonitor: FileProviderBasic {
    func isRegisteredForNotification(path: String) -> Bool
 }

-public protocol FileProvider: FileProviderBasic, FileProviderOperations, FileProviderReadWrite {
-    
+public protocol FileProvider: FileProviderBasic, FileProviderOperations, FileProviderReadWrite, NSCopying {
 }

 extension FileProviderBasic {
    public var type: String {
-        return type(of: self).type
+        return Self.type
    }
    
    public var bareCurrentPath: String {
@@ -193,7 +168,7 @@ extension FileProviderBasic {
        guard let path = path else { return nil }
        var p = path.hasPrefix("/") ? path : "/" + path
        if p.hasSuffix("/") {
-            p.remove(at: p.characters.index(before: p.endIndex))
+            p.remove(at: p.endIndex)
        }
        return p
    }
@@ -269,12 +244,10 @@ extension FileProviderBasic {
        if let isotime = dateFor.date(from: dateString) {
            return isotime
        }
-        //self.init()
        return nil
    }
 }

-
 public protocol ExtendedFileProvider: FileProvider {
    func thumbnailOfFileSupported(path: String) -> Bool
    func propertiesOfFileSupported(path: String) -> Bool
@@ -289,43 +262,166 @@ public enum FileOperationType: CustomStringConvertible {
    case modify (path: String)
    case remove (path: String)
    case link   (link: String, target: String)
+    case fetch  (path: String)
    
    public var description: String {
        switch self {
-        case .create(path: _): return "Create"
-        case .copy(source: _, destination: _): return "Copy"
-        case .move(source: _, destination: _): return "Move"
-        case .modify(path: _): return "Modify"
-        case .remove(path: _): return "Remove"
-        case .link(link: _, target: _): return "Link"
+        case .create: return "Create"
+        case .copy: return "Copy"
+        case .move: return "Move"
+        case .modify: return "Modify"
+        case .remove: return "Remove"
+        case .link: return "Link"
+        case .fetch: return "Fetch"
        }
    }
    
    public var actionDescription: String {
-        switch self {
-        case .create(path: _): return "Creating"
-        case .copy(source: _, destination: _): return "Copying"
-        case .move(source: _, destination: _): return "Moving"
-        case .modify(path: _): return "Modifying"
-        case .remove(path: _): return "Removing"
-        case .link(link: _, target: _): return "Linking"
-        }
+        return description.trimmingCharacters(in: CharacterSet(charactersIn: "e")) + "ing"
+    }
+    
+    public var source: String? {
+        guard let reflect = Mirror(reflecting: self).children.first?.value else { return nil }
+        let mirror = Mirror(reflecting: reflect)
+        return reflect as? String ?? mirror.children.first?.value as? String
+    }
+    
+    public var destination: String? {
+        guard let reflect = Mirror(reflecting: self).children.first?.value else { return nil }
+        let mirror = Mirror(reflecting: reflect)
+        return mirror.children.dropFirst().first?.value as? String
+    }
+    
+    internal var json: String? {
+        var dictionary: [String: AnyObject] = ["type": self.description as NSString]
+        dictionary["source"] = source as NSString?
+        dictionary["dest"] = destination as NSString?
+        return dictionaryToJSON(dictionary)
+    }
+}
+
+open class FileObject {
+    open internal(set) var allValues: [String: Any]
+    
+    internal init(allValues: [String: Any]) {
+        self.allValues = allValues
+    }
+    
+    internal init(absoluteURL: URL? = nil, name: String, path: String) {
+        self.allValues = [String: Any]()
+        self.absoluteURL = absoluteURL
+        self.name = name
+        self.path = path
+    }
+    
+    open internal(set) var absoluteURL: URL? {
+        get {
+            return allValues["NSURLAbsoluteURLKey"] as? URL
+        }
+        set {
+            allValues["NSURLAbsoluteURLKey"] = newValue
+        }
+    }
+    
+    open internal(set) var name: String {
+        get {
+            return allValues[URLResourceKey.nameKey.rawValue] as! String
+        }
+        set {
+            allValues[URLResourceKey.nameKey.rawValue] = newValue
+        }
+    }
+    
+    open internal(set) var path: String {
+        get {
+            return allValues[URLResourceKey.pathKey.rawValue] as! String
+        }
+        set {
+            allValues[URLResourceKey.pathKey.rawValue] = newValue
+        }
+    }
+    
+    open internal(set) var size: Int64 {
+        get {
+            return allValues[URLResourceKey.fileSizeKey.rawValue] as? Int64 ?? -1
+        }
+        set {
+            allValues[URLResourceKey.fileSizeKey.rawValue] = Int(exactly: newValue) ?? Int.max
+        }
+    }
+    
+    open internal(set) var creationDate: Date? {
+        get {
+            return allValues[URLResourceKey.creationDateKey.rawValue] as? Date
+        }
+        set {
+            allValues[URLResourceKey.creationDateKey.rawValue] = newValue
+        }
+    }
+    
+    open internal(set) var modifiedDate: Date? {
+        get {
+            return allValues[URLResourceKey.contentModificationDateKey.rawValue] as? Date
+        }
+        set {
+            allValues[URLResourceKey.contentModificationDateKey.rawValue] = newValue
+        }
+    }
+    
+    open internal(set) var fileType: URLFileResourceType? {
+        get {
+            return allValues[URLResourceKey.fileResourceTypeKey.rawValue] as? URLFileResourceType
+        }
+        set {
+            allValues[URLResourceKey.fileResourceTypeKey.rawValue] = newValue
+        }
+    }
+    
+    open internal(set) var isHidden: Bool {
+        get {
+            return allValues[URLResourceKey.isHiddenKey.rawValue] as? Bool ?? false
+        }
+        set {
+            allValues[URLResourceKey.isHiddenKey.rawValue] = newValue
+        }
+    }
+    
+    open internal(set) var isReadOnly: Bool {
+        get {
+            return !(allValues[URLResourceKey.isWritableKey.rawValue] as? Bool ?? true)
+        }
+        set {
+            allValues[URLResourceKey.isWritableKey.rawValue] = !newValue
+        }
+    }
+    
+    open var isDirectory: Bool {
+        return self.fileType == .directory
+    }
+    
+    open var isRegularFile: Bool {
+        return self.fileType == .regular
+    }
+    
+    open var isSymLink: Bool {
+        return self.fileType == .symbolicLink
    }
 }

-@objc
 public protocol OperationHandle {
-    var progress: Float { get }
+    var operationType: FileOperationType { get }
    var bytesSoFar: Int64 { get }
    var totalBytes: Int64 { get }
    var inProgress: Bool { get }
-    func cancel()
+    var progress: Float { get }
+    func cancel() -> Bool
 }

-internal class Weak<T: AnyObject> {
-    weak var value : T?
-    init (_ value: T) {
-        self.value = value
+public extension OperationHandle {
+    public var progress: Float {
+        let bytesSoFar = self.bytesSoFar
+        let totalBytes = self.totalBytes
+        return totalBytes > 0 ? Float(Double(bytesSoFar) / Double(totalBytes)) : Float.nan
    }
 }

@@ -345,13 +441,42 @@ public protocol FileOperationDelegate: class {
 }

 // THESE ARE METHODS TO PROVIDE COMPATIBILITY WITH SWIFT 2.3 SIMOULTANIOUSLY!
-
 internal extension URL {
    var uw_scheme: String {
        return self.scheme ?? ""
    }
 }

+internal class Weak<T: AnyObject> {
+    weak var value : T?
+    init (_ value: T) {
+        self.value = value
+    }
+}
+
+extension URLFileResourceType {
+    public init(fileTypeValue: FileAttributeType) {
+        switch fileTypeValue {
+        case FileAttributeType.typeCharacterSpecial: self = .characterSpecial
+        case FileAttributeType.typeDirectory: self = .directory
+        case FileAttributeType.typeBlockSpecial: self = .blockSpecial
+        case FileAttributeType.typeRegular: self = .regular
+        case FileAttributeType.typeSymbolicLink: self = .symbolicLink
+        case FileAttributeType.typeSocket: self = .socket
+        case FileAttributeType.typeUnknown: self = .unknown
+        default: self = .unknown
+        }
+    }
+}
+
+public protocol FoundationErrorEnum {
+    init? (rawValue: Int)
+    var rawValue: Int { get }
+}
+
+extension URLError.Code: FoundationErrorEnum {}
+extension CocoaError.Code: FoundationErrorEnum {}
+
 internal func jsonToDictionary(_ jsonString: String) -> [String: AnyObject]? {
    guard let data = jsonString.data(using: .utf8) else {
        return nil
@@ -8,28 +8,18 @@

 import Foundation

-public final class LocalFileObject: FileObject {
-    public let allocatedSize: Int64
-    // codebeat:disable[ARITY]
-    public init(absoluteURL: URL, name: String, path: String, size: Int64 = -1, allocatedSize: Int64 = 0, createdDate: Date? = nil, modifiedDate: Date? = nil, fileType: FileType = .regular, isHidden: Bool = false, isReadOnly: Bool = false) {
-        self.allocatedSize = allocatedSize
-        super.init(absoluteURL: absoluteURL, name: name, path: path, size: size, createdDate: createdDate, modifiedDate: modifiedDate, fileType: fileType, isHidden: isHidden, isReadOnly: isReadOnly)
-    }
-    // codebeat:enable[ARITY]
-}
-
 open class LocalFileProvider: FileProvider, FileProviderMonitor {
    open static let type = "Local"
    open var isPathRelative: Bool = true
-    open var baseURL: URL? = LocalFileProvider.defaultBaseURL()
+    open private(set) var baseURL: URL? = LocalFileProvider.defaultBaseURL()
    open var currentPath: String = ""
    open var dispatch_queue: DispatchQueue
    open var operation_queue: DispatchQueue
    open weak var delegate: FileProviderDelegate?
    open let credential: URLCredential? = nil
        
-    open let fileManager = FileManager()
-    open let opFileManager = FileManager()
+    open private(set) var fileManager = FileManager()
+    open private(set) var opFileManager = FileManager()
    fileprivate var fileProviderManagerDelegate: LocalFileProviderManagerDelegate? = nil
    
    public init () {
@@ -47,17 +37,18 @@ open class LocalFileProvider: FileProvider, FileProviderMonitor {
        opFileManager.delegate = fileProviderManagerDelegate
    }
    
-    fileprivate static func defaultBaseURL() -> URL {
-        let paths = NSSearchPathForDirectoriesInDomains(FileManager.SearchPathDirectory.documentDirectory, FileManager.SearchPathDomainMask.userDomainMask, true);
+    open static func defaultBaseURL() -> URL {
+        let paths = NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true);
        return URL(fileURLWithPath: paths[0])
    }
    
    open func contentsOfDirectory(path: String, completionHandler: @escaping ((_ contents: [FileObject], _ error: Error?) -> Void)) {
        dispatch_queue.async {
            do {
-                let contents = try self.fileManager.contentsOfDirectory(at: self.absoluteURL(path), includingPropertiesForKeys: [URLResourceKey.nameKey, URLResourceKey.fileSizeKey, URLResourceKey.fileAllocatedSizeKey, URLResourceKey.creationDateKey, URLResourceKey.contentModificationDateKey, URLResourceKey.isHiddenKey, URLResourceKey.volumeIsReadOnlyKey], options: FileManager.DirectoryEnumerationOptions.skipsSubdirectoryDescendants)
-                let filesAttributes = contents.map({ (fileURL) -> LocalFileObject in
-                    return self.attributesOfItem(url: fileURL)
+                let contents = try self.fileManager.contentsOfDirectory(at: self.absoluteURL(path), includingPropertiesForKeys: [.nameKey, .fileSizeKey, .fileAllocatedSizeKey, .creationDateKey, .contentModificationDateKey, .isHiddenKey, .volumeIsReadOnlyKey], options: .skipsSubdirectoryDescendants)
+                let filesAttributes = contents.flatMap({ (fileURL) -> LocalFileObject? in
+                    let path = self.relativePathOf(url: fileURL)
+                    return LocalFileObject(fileWithPath: path, relativeTo: self.baseURL)
                })
                completionHandler(filesAttributes, nil)
            } catch let e as NSError {
@@ -66,98 +57,65 @@ open class LocalFileProvider: FileProvider, FileProviderMonitor {
        }
    }
    
-    internal func attributesOfItem(url fileURL: URL) -> LocalFileObject {
-        var namev, sizev, allocated, filetypev, creationDatev, modifiedDatev, hiddenv, readonlyv: AnyObject?
-        _ = try? (fileURL as NSURL).getResourceValue(&namev, forKey: URLResourceKey.nameKey)
-        _ = try? (fileURL as NSURL).getResourceValue(&sizev, forKey: URLResourceKey.fileSizeKey)
-        _ = try? (fileURL as NSURL).getResourceValue(&allocated, forKey: URLResourceKey.fileAllocatedSizeKey)
-        _ = try? (fileURL as NSURL).getResourceValue(&creationDatev, forKey: URLResourceKey.creationDateKey)
-        _ = try? (fileURL as NSURL).getResourceValue(&modifiedDatev, forKey: URLResourceKey.contentModificationDateKey)
-        _ = try? (fileURL as NSURL).getResourceValue(&filetypev, forKey: URLResourceKey.fileResourceTypeKey)
-        _ = try? (fileURL as NSURL).getResourceValue(&hiddenv, forKey: URLResourceKey.isHiddenKey)
-        _ = try? (fileURL as NSURL).getResourceValue(&readonlyv, forKey: URLResourceKey.volumeIsReadOnlyKey)
-        let path: String
-        if isPathRelative {
-            path = self.relativePathOf(url: fileURL)
-        } else {
-            path = fileURL.path
-        }
-        let filetype = URLFileResourceType(rawValue: filetypev as? String ?? "")
-        let fileAttr = LocalFileObject(absoluteURL: fileURL, name: namev as! String, path: path, size: sizev?.int64Value ?? -1, allocatedSize: allocated?.int64Value ?? -1, createdDate: creationDatev as? Date, modifiedDate: modifiedDatev as? Date, fileType: FileType(urlResourceTypeValue: filetype), isHidden: hiddenv?.boolValue ?? false, isReadOnly: readonlyv?.boolValue ?? false)
-        return fileAttr
-    }
-    
    open func storageProperties(completionHandler: (@escaping (_ total: Int64, _ used: Int64) -> Void)) {
        let dict = (try? FileManager.default.attributesOfFileSystem(forPath: baseURL?.path ?? "/"))
-        let totalSize = (dict?[FileAttributeKey.systemSize] as? NSNumber)?.int64Value ?? -1;
-        let freeSize = (dict?[FileAttributeKey.systemFreeSize] as? NSNumber)?.int64Value ?? 0;
+        let totalSize = (dict?[.systemSize] as? NSNumber)?.int64Value ?? -1;
+        let freeSize = (dict?[.systemFreeSize] as? NSNumber)?.int64Value ?? 0;
        completionHandler(totalSize, totalSize - freeSize)
    }
    
    open func attributesOfItem(path: String, completionHandler: @escaping ((_ attributes: FileObject?, _ error: Error?) -> Void)) {
        dispatch_queue.async {
-            completionHandler(self.attributesOfItem(url: self.absoluteURL(path)), nil)
+            completionHandler(LocalFileObject(fileWithPath: path, relativeTo: self.baseURL), nil)
        }
    }
    
    open weak var fileOperationDelegate : FileOperationDelegate?
    
-    @objc(createWithFolder:at:completionHandler:)
    @discardableResult
    open func create(folder folderName: String, at atPath: String, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
+        let opType = FileOperationType.create(path: (atPath as NSString).appendingPathComponent(folderName) + "/")
        operation_queue.async {
            do {
                try self.opFileManager.createDirectory(at: self.absoluteURL(atPath).appendingPathComponent(folderName), withIntermediateDirectories: true, attributes: [:])
                completionHandler?(nil)
                DispatchQueue.main.async(execute: {
-                    self.delegate?.fileproviderSucceed(self, operation: .create(path: (atPath as NSString).appendingPathComponent(folderName) + "/"))
+                    self.delegate?.fileproviderSucceed(self, operation: opType)
                })
            } catch let e as NSError {
                completionHandler?(e)
                DispatchQueue.main.async(execute: {
-                    self.delegate?.fileproviderFailed(self, operation: .create(path: (atPath as NSString).appendingPathComponent(folderName) + "/"))
+                    self.delegate?.fileproviderFailed(self, operation: opType)
                })
            }
        }
-        return nil
+        return LocalOperationHandle(operationType: opType, baseURL: self.baseURL)
    }
    
    @discardableResult
-    open func create(file fileAttribs: FileObject, at atPath: String, contents data: Data?, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
+    open func create(file fileName: String, at atPath: String, contents data: Data?, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
+        let opType = FileOperationType.create(path: (atPath as NSString).appendingPathComponent(fileName))
        operation_queue.async {
-            let fileURL = self.absoluteURL(atPath).appendingPathComponent(fileAttribs.name)
-            var attributes = [String : Any]()
-            if let createdDate = fileAttribs.createdDate {
-                attributes[FileAttributeKey.creationDate.rawValue] = createdDate as NSDate
-            }
-            if let modDate = fileAttribs.modifiedDate {
-                attributes[FileAttributeKey.modificationDate.rawValue] = modDate as NSDate
-            }
-            if fileAttribs.isReadOnly {
-                attributes[FileAttributeKey.posixPermissions.rawValue] = NSNumber(value: 365 as Int16)
-            }
-            let success = self.opFileManager.createFile(atPath: fileURL.path, contents: data, attributes: attributes)
+            let fileURL = self.absoluteURL(atPath).appendingPathComponent(fileName)
+            let success = self.opFileManager.createFile(atPath: fileURL.path, contents: data, attributes: nil)
            if success {
-                do {
-                    try (fileURL as NSURL).setResourceValue(fileAttribs.isHidden, forKey: URLResourceKey.isHiddenKey)
-                } catch _ {}
                completionHandler?(nil)
                DispatchQueue.main.async(execute: {
-                    self.delegate?.fileproviderSucceed(self, operation: .create(path: (atPath as NSString).appendingPathComponent(fileAttribs.name)))
+                    self.delegate?.fileproviderSucceed(self, operation: opType)
                })
            } else {
                completionHandler?(self.throwError(atPath, code: URLError.cannotCreateFile as FoundationErrorEnum))
                DispatchQueue.main.async(execute: {
-                    self.delegate?.fileproviderFailed(self, operation: .create(path: (atPath as NSString).appendingPathComponent(fileAttribs.name)))
+                    self.delegate?.fileproviderFailed(self, operation: opType)
                })
            }
        }
-        return nil
+        return LocalOperationHandle(operationType: opType, baseURL: self.baseURL)
    }
    
    @discardableResult
    open func moveItem(path: String, to toPath: String, overwrite: Bool = false, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
-        // FIXME: progress
+        let opType = FileOperationType.move(source: path, destination: toPath)
        operation_queue.async {
            if !overwrite && self.fileManager.fileExists(atPath: self.absoluteURL(toPath).path) {
                completionHandler?(self.throwError(toPath, code: URLError.cannotMoveFile as FoundationErrorEnum))
@@ -167,21 +125,21 @@ open class LocalFileProvider: FileProvider, FileProviderMonitor {
                try self.opFileManager.moveItem(at: self.absoluteURL(path), to: self.absoluteURL(toPath))
                completionHandler?(nil)
                DispatchQueue.main.async(execute: {
-                    self.delegate?.fileproviderSucceed(self, operation: .move(source: path, destination: toPath))
+                    self.delegate?.fileproviderSucceed(self, operation: opType)
                })
            } catch let e as NSError {
                completionHandler?(e)
                DispatchQueue.main.async(execute: {
-                    self.delegate?.fileproviderFailed(self, operation: .move(source: path, destination: toPath))
+                    self.delegate?.fileproviderFailed(self, operation: opType)
                })
            }
        }
-        return nil
+        return LocalOperationHandle(operationType: opType, baseURL: self.baseURL)
    }
    
    @discardableResult
    open func copyItem(path: String, to toPath: String, overwrite: Bool = false, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
-        // FIXME: progress, for files > 100mb, monitor file by another thread, for dirs check copied items count
+        let opType = FileOperationType.copy(source: path, destination: toPath)
        operation_queue.async {
            if !overwrite && self.fileManager.fileExists(atPath: self.absoluteURL(toPath).path) {
                completionHandler?(self.throwError(toPath, code: URLError.cannotWriteToFile as FoundationErrorEnum))
@@ -191,73 +149,76 @@ open class LocalFileProvider: FileProvider, FileProviderMonitor {
                try self.opFileManager.copyItem(at: self.absoluteURL(path), to: self.absoluteURL(toPath))
                completionHandler?(nil)
                DispatchQueue.main.async(execute: {
-                    self.delegate?.fileproviderSucceed(self, operation: .copy(source: path, destination: toPath))
+                    self.delegate?.fileproviderSucceed(self, operation: opType)
                })
            } catch let e as NSError {
                completionHandler?(e)
                DispatchQueue.main.async(execute: {
-                    self.delegate?.fileproviderFailed(self, operation: .copy(source: path, destination: toPath))
+                    self.delegate?.fileproviderFailed(self, operation: opType)
                })
            }
        }
-        return nil
+        return LocalOperationHandle(operationType: opType, baseURL: self.baseURL)
    }
    
    @discardableResult
    open func removeItem(path: String, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
+        let opType = FileOperationType.remove(path: path)
        operation_queue.async {
            do {
                try self.opFileManager.removeItem(at: self.absoluteURL(path))
                completionHandler?(nil)
                DispatchQueue.main.async(execute: {
-                    self.delegate?.fileproviderSucceed(self, operation: .remove(path: path))
+                    self.delegate?.fileproviderSucceed(self, operation: opType)
                })
            } catch let e as NSError {
                completionHandler?(e)
                DispatchQueue.main.async(execute: {
-                    self.delegate?.fileproviderFailed(self, operation: .remove(path: path))
+                    self.delegate?.fileproviderFailed(self, operation: opType)
                })
            }
        }
-        return nil
+        return LocalOperationHandle(operationType: opType, baseURL: self.baseURL)
    }
    
    @discardableResult
    open func copyItem(localFile: URL, to toPath: String, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
+        let opType = FileOperationType.copy(source: localFile.absoluteString, destination: toPath)
        operation_queue.async {
            do {
                try self.opFileManager.copyItem(at: localFile, to: self.absoluteURL(toPath))
                completionHandler?(nil)
                DispatchQueue.main.async(execute: {
-                    self.delegate?.fileproviderSucceed(self, operation: .copy(source: localFile.absoluteString, destination: toPath))
+                    self.delegate?.fileproviderSucceed(self, operation: opType)
                })
            } catch let e as NSError {
                completionHandler?(e)
                DispatchQueue.main.async(execute: {
-                    self.delegate?.fileproviderFailed(self, operation: .copy(source: localFile.absoluteString, destination: toPath))
+                    self.delegate?.fileproviderFailed(self, operation: opType)
                })
            }
        }
-        return nil
+        return LocalOperationHandle(operationType: opType, baseURL: self.baseURL)
    }
    
    @discardableResult
    open func copyItem(path: String, toLocalURL: URL, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
+        let opType = FileOperationType.copy(source: path, destination: toLocalURL.absoluteString)
        operation_queue.async {
            do {
                try self.opFileManager.copyItem(at: self.absoluteURL(path), to: toLocalURL)
                completionHandler?(nil)
                DispatchQueue.main.async(execute: {
-                    self.delegate?.fileproviderSucceed(self, operation: .copy(source: path, destination: toLocalURL.absoluteString))
+                    self.delegate?.fileproviderSucceed(self, operation: opType)
                })
            } catch let e as NSError {
                completionHandler?(e)
                DispatchQueue.main.async(execute: {
-                    self.delegate?.fileproviderFailed(self, operation: .copy(source: path, destination: toLocalURL.absoluteString))
+                    self.delegate?.fileproviderFailed(self, operation: opType)
                })
            }
        }
-        return nil
+        return LocalOperationHandle(operationType: opType, baseURL: self.baseURL)
    }
    
    @discardableResult
@@ -271,58 +232,54 @@ open class LocalFileProvider: FileProvider, FileProviderMonitor {
    
    @discardableResult
    open func contents(path: String, offset: Int64, length: Int, completionHandler: @escaping ((_ contents: Data?, _ error: Error?) -> Void)) -> OperationHandle? {
-        // Unfortunatlely there is no method provided in NSFileManager to read a segment of file.
-        // So we have to fallback to POSIX provided methods
+        let opType = FileOperationType.fetch(path: path)
        dispatch_queue.async {
            let aPath = self.absoluteURL(path).path
-            guard !self.attributesOfItem(url: self.absoluteURL(path)).isDirectory && self.fileManager.fileExists(atPath: aPath) else {
+            guard self.fileManager.fileExists(atPath: aPath) && !self.absoluteURL(path).fileIsDirectory else {
                completionHandler(nil, self.throwError(path, code: URLError.cannotOpenFile as FoundationErrorEnum))
                return
            }
-            let fd_from = open(aPath, O_RDONLY)
-            if fd_from < 0 {
+            guard let handle = FileHandle(forReadingAtPath: aPath) else {
                completionHandler(nil, self.throwError(path, code: URLError.cannotOpenFile as FoundationErrorEnum))
                return
            }
-            defer { precondition(close(fd_from) >= 0) }
-            lseek(fd_from, offset, SEEK_SET)
-            var buf = [UInt8](repeating: 0, count: length)
-            let nread = read(fd_from, &buf, buf.count)
-            if nread < 0 {
-                completionHandler(nil, self.throwError(path, code: URLError.noPermissionsToReadFile as FoundationErrorEnum))
-            } else if nread == 0 {
-                completionHandler(nil, nil)
-            } else {
-                let data = Data(bytesNoCopy: UnsafeMutablePointer<UInt8>(&buf), count: nread, deallocator: .free)
-                completionHandler(data, nil)
+            defer {
+                handle.closeFile()
            }
+            handle.seek(toFileOffset: UInt64(offset))
+            let data = handle.readData(ofLength: length)
+            completionHandler(data, nil)
+            
        }
-        return nil
+        return LocalOperationHandle(operationType: opType, baseURL: self.baseURL)
    }
    
    @discardableResult
    open func writeContents(path: String, contents data: Data, atomically: Bool, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
+        let opType = FileOperationType.modify(path: path)
        operation_queue.async {
            try? data.write(to: self.absoluteURL(path), options: atomically ? [.atomic] : [])
            DispatchQueue.main.async(execute: {
-                self.delegate?.fileproviderSucceed(self, operation: .modify(path: path))
+                self.delegate?.fileproviderSucceed(self, operation: opType)
            })
        }
-        return nil
+        return LocalOperationHandle(operationType: opType, baseURL: self.baseURL)
    }
    
    open func searchFiles(path: String, recursive: Bool, query: String, foundItemHandler: ((FileObject) -> Void)?, completionHandler: @escaping ((_ files: [FileObject], _ error: Error?) -> Void)) {
        dispatch_queue.async { 
-            let iterator = self.fileManager.enumerator(at: self.absoluteURL(path), includingPropertiesForKeys: nil, options: recursive ? FileManager.DirectoryEnumerationOptions() : .skipsSubdirectoryDescendants) { (url, e) -> Bool in
+            let iterator = self.fileManager.enumerator(at: self.absoluteURL(path), includingPropertiesForKeys: nil, options: recursive ? [] : [.skipsSubdirectoryDescendants, .skipsPackageDescendants]) { (url, e) -> Bool in
                completionHandler([], e)
                return true
            }
            var result = [LocalFileObject]()
            while let fileURL = iterator?.nextObject() as? URL {
                if fileURL.lastPathComponent.lowercased().contains(query.lowercased()) {
-                    let fileObject = self.attributesOfItem(url: fileURL)
-                    result.append(self.attributesOfItem(url: fileURL))
-                    foundItemHandler?(fileObject)
+                    let path = self.relativePathOf(url: fileURL)
+                    if let fileObject = LocalFileObject(fileWithPath: path, relativeTo: self.baseURL) {
+                        result.append(fileObject)
+                        foundItemHandler?(fileObject)
+                    }
                }
            }
            completionHandler(result, nil)
@@ -334,12 +291,8 @@ open class LocalFileProvider: FileProvider, FileProviderMonitor {
    open func registerNotifcation(path: String, eventHandler: @escaping (() -> Void)) {
        self.unregisterNotifcation(path: path)
        let absurl = self.absoluteURL(path)
-        var isdirv: AnyObject?
-        do {
-            try (absurl as NSURL).getResourceValue(&isdirv, forKey: URLResourceKey.isDirectoryKey)
-        } catch _ {
-        }
-        if !(isdirv?.boolValue ?? false) {
+        let isdir = (try? absurl.resourceValues(forKeys: [.isDirectoryKey]).isDirectory ?? false) ?? false
+        if !isdir {
            return
        }
        let monitor = LocalFolderMonitor(url: absurl) {
@@ -363,6 +316,15 @@ open class LocalFileProvider: FileProvider, FileProviderMonitor {
    open func isRegisteredForNotification(path: String) -> Bool {
        return monitors.map( { self.relativePathOf(url: $0.url) } ).contains(path)
    }
+    
+    open func copy(with zone: NSZone? = nil) -> Any {
+        let copy = LocalFileProvider(baseURL: self.baseURL!)
+        copy.currentPath = self.currentPath
+        copy.delegate = self.delegate
+        copy.fileOperationDelegate = self.fileOperationDelegate
+        copy.isPathRelative = self.isPathRelative
+        return copy
+    }
 }

 public extension LocalFileProvider {
@@ -383,135 +345,3 @@ public extension LocalFileProvider {
        }
    }
 }
-
-internal class LocalFileProviderManagerDelegate: NSObject, FileManagerDelegate {
-    weak var provider: LocalFileProvider?
-    
-    init(provider: LocalFileProvider) {
-        self.provider = provider
-    }
-    
-    func fileManager(_ fileManager: FileManager, shouldCopyItemAt srcURL: URL, to dstURL: URL) -> Bool {
-        guard let provider = self.provider, let delegate = provider.fileOperationDelegate else {
-            return true
-        }
-        let srcPath = provider.relativePathOf(url: srcURL)
-        let dstPath = provider.relativePathOf(url: dstURL)
-        return delegate.fileProvider(provider, shouldDoOperation: .copy(source: srcPath, destination: dstPath))
-    }
-    
-    func fileManager(_ fileManager: FileManager, shouldMoveItemAt srcURL: URL, to dstURL: URL) -> Bool {
-        guard let provider = self.provider, let delegate = provider.fileOperationDelegate else {
-            return true
-        }
-        let srcPath = provider.relativePathOf(url: srcURL)
-        let dstPath = provider.relativePathOf(url: dstURL)
-        return delegate.fileProvider(provider, shouldDoOperation: .move(source: srcPath, destination: dstPath))
-    }
-    
-    func fileManager(_ fileManager: FileManager, shouldRemoveItemAt URL: URL) -> Bool {
-        guard let provider = self.provider, let delegate = provider.fileOperationDelegate else {
-            return true
-        }
-        let path = provider.relativePathOf(url: URL)
-        return delegate.fileProvider(provider, shouldDoOperation: .remove(path: path))
-    }
-    
-    func fileManager(_ fileManager: FileManager, shouldLinkItemAt srcURL: URL, to dstURL: URL) -> Bool {
-        guard let provider = self.provider, let delegate = provider.fileOperationDelegate else {
-            return true
-        }
-        let srcPath = provider.relativePathOf(url: srcURL)
-        let dstPath = provider.relativePathOf(url: dstURL)
-        return delegate.fileProvider(provider, shouldDoOperation: .link(link: srcPath, target: dstPath))
-    }
-    
-    func fileManager(_ fileManager: FileManager, shouldProceedAfterError error: Error, copyingItemAt srcURL: URL, to dstURL: URL) -> Bool {
-        guard let provider = self.provider, let delegate = provider.fileOperationDelegate else {
-            return false
-        }
-        let srcPath = provider.relativePathOf(url: srcURL)
-        let dstPath = provider.relativePathOf(url: dstURL)
-        return delegate.fileProvider(provider, shouldProceedAfterError: error, operation: .copy(source: srcPath, destination: dstPath))
-    }
-    
-    func fileManager(_ fileManager: FileManager, shouldProceedAfterError error: Error, movingItemAt srcURL: URL, to dstURL: URL) -> Bool {
-        guard let provider = self.provider, let delegate = provider.fileOperationDelegate else {
-            return false
-        }
-        let srcPath = provider.relativePathOf(url: srcURL)
-        let dstPath = provider.relativePathOf(url: dstURL)
-        return delegate.fileProvider(provider, shouldProceedAfterError: error, operation: .move(source: srcPath, destination: dstPath))
-    }
-    
-    func fileManager(_ fileManager: FileManager, shouldProceedAfterError error: Error, removingItemAt URL: URL) -> Bool {
-        guard let provider = self.provider, let delegate = provider.fileOperationDelegate else {
-            return false
-        }
-        let path = provider.relativePathOf(url: URL)
-        return delegate.fileProvider(provider, shouldProceedAfterError: error, operation: .remove(path: path))
-    }
-    
-    func fileManager(_ fileManager: FileManager, shouldProceedAfterError error: Error, linkingItemAt srcURL: URL, to dstURL: URL) -> Bool {
-        guard let provider = self.provider, let delegate = provider.fileOperationDelegate else {
-            return false
-        }
-        let srcPath = provider.relativePathOf(url: srcURL)
-        let dstPath = provider.relativePathOf(url: dstURL)
-        return delegate.fileProvider(provider, shouldProceedAfterError: error, operation: .link(link: srcPath, target: dstPath))
-    }
-}
-
-internal class LocalFolderMonitor {
-    fileprivate let source: DispatchSourceFileSystemObject
-    fileprivate let descriptor: CInt
-    fileprivate let qq: DispatchQueue = DispatchQueue.global(qos: DispatchQoS.QoSClass.default)
-    fileprivate var state: Bool = false
-    fileprivate var monitoredTime: TimeInterval = Date().timeIntervalSinceReferenceDate
-    var url: URL
-    
-    /// Creates a folder monitor object with monitoring enabled.
-    init(url: URL, handler: @escaping ()->Void) {
-        self.url = url
-        descriptor = open((url as NSURL).fileSystemRepresentation, O_EVTONLY)
-        source = DispatchSource.makeFileSystemObjectSource(fileDescriptor: descriptor, eventMask: DispatchSource.FileSystemEvent.write, queue: qq)
-        // Folder monitoring is recursive and deep. Monitoring a root folder may be very costly
-        // We have a 0.2 second delay to ensure we wont call handler 1000s times when there is
-        // a huge file operation. This ensures app will work smoothly while this 250 milisec won't
-        // affect user experince much
-        let main_handler: ()->Void = {
-            if Date().timeIntervalSinceReferenceDate < self.monitoredTime + 0.2 {
-                return
-            }
-            self.monitoredTime = Date().timeIntervalSinceReferenceDate
-            DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 0.25, execute: {
-                handler()
-            })
-        }
-        source.setEventHandler(handler: main_handler)
-        source.setCancelHandler {
-            close(self.descriptor)
-        }
-        start()
-    }
-    
-    /// Starts sending notifications if currently stopped
-    func start() {
-        if !state {
-            state = true
-            source.resume()
-        }
-    }
-    
-    /// Stops sending notifications if currently enabled
-    func stop() {
-        if state {
-            state = false
-            source.suspend()
-        }
-    }
-    
-    deinit {
-        source.cancel()
-    }
-}
@@ -0,0 +1,298 @@
+//
+//  LocalFileProvider.swift
+//  FileProvider
+//
+//  Created by Amir Abbas Mousavian.
+//  Copyright © 2016 Mousavian. Distributed under MIT license.
+//
+
+import Foundation
+
+public final class LocalFileObject: FileObject {
+    internal init(absoluteURL: URL, name: String, path: String) {
+        super.init(absoluteURL: absoluteURL, name: name, path: path)
+    }
+    
+    public convenience init? (fileWithPath path: String, relativeTo relativeURL: URL?) {
+        let fileURL: URL
+        if let relativeURL = relativeURL {
+            fileURL = relativeURL.appendingPathComponent(path)
+        } else {
+            fileURL = URL(fileURLWithPath: path)
+        }
+        do {
+            let values = try fileURL.resourceValues(forKeys: [.nameKey, .fileSizeKey, .fileAllocatedSizeKey, .creationDateKey, .contentModificationDateKey, .fileResourceTypeKey, .isHiddenKey, .isWritableKey])
+            self.init(absoluteURL: fileURL, name: values.name ?? fileURL.lastPathComponent, path: path)
+            for (key, value) in values.allValues {
+                self.allValues[key.rawValue] = value
+            }
+        } catch {
+            return nil
+        }
+    }
+    
+    public convenience init?(fileWithURL fileURL: URL) {
+        do {
+            let values = try fileURL.resourceValues(forKeys: [.nameKey, .fileSizeKey, .fileAllocatedSizeKey, .creationDateKey, .contentModificationDateKey, .fileResourceTypeKey, .isHiddenKey, .isWritableKey, .typeIdentifierKey])
+            self.init(absoluteURL: fileURL, name: values.name ?? fileURL.lastPathComponent, path: fileURL.path)
+            for (key, value) in values.allValues {
+                self.allValues[key.rawValue] = value
+            }
+        } catch {
+            return nil
+        }
+    }
+    
+    open internal(set) var allocatedSize: Int64 {
+        get {
+            return allValues[URLResourceKey.fileAllocatedSizeKey.rawValue] as? Int64 ?? 0
+        }
+        set {
+            allValues[URLResourceKey.fileAllocatedSizeKey.rawValue] = Int(exactly: newValue) ?? Int.max
+        }
+    }
+}
+
+internal class LocalFolderMonitor {
+    fileprivate let source: DispatchSourceFileSystemObject
+    fileprivate let descriptor: CInt
+    fileprivate let qq: DispatchQueue = DispatchQueue.global(qos: DispatchQoS.QoSClass.default)
+    fileprivate var state: Bool = false
+    fileprivate var monitoredTime: TimeInterval = Date().timeIntervalSinceReferenceDate
+    var url: URL
+    
+    /// Creates a folder monitor object with monitoring enabled.
+    init(url: URL, handler: @escaping ()->Void) {
+        self.url = url
+        descriptor = open((url as NSURL).fileSystemRepresentation, O_EVTONLY)
+        source = DispatchSource.makeFileSystemObjectSource(fileDescriptor: descriptor, eventMask: DispatchSource.FileSystemEvent.write, queue: qq)
+        // Folder monitoring is recursive and deep. Monitoring a root folder may be very costly
+        // We have a 0.2 second delay to ensure we wont call handler 1000s times when there is
+        // a huge file operation. This ensures app will work smoothly while this 250 milisec won't
+        // affect user experince much
+        let main_handler: ()->Void = {
+            if Date().timeIntervalSinceReferenceDate < self.monitoredTime + 0.2 {
+                return
+            }
+            self.monitoredTime = Date().timeIntervalSinceReferenceDate
+            DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 0.25, execute: {
+                handler()
+            })
+        }
+        source.setEventHandler(handler: main_handler)
+        source.setCancelHandler {
+            close(self.descriptor)
+        }
+        start()
+    }
+    
+    /// Starts sending notifications if currently stopped
+    func start() {
+        if !state {
+            state = true
+            source.resume()
+        }
+    }
+    
+    /// Stops sending notifications if currently enabled
+    func stop() {
+        if state {
+            state = false
+            source.suspend()
+        }
+    }
+    
+    deinit {
+        source.cancel()
+    }
+}
+
+internal class LocalFileProviderManagerDelegate: NSObject, FileManagerDelegate {
+    weak var provider: LocalFileProvider?
+    
+    init(provider: LocalFileProvider) {
+        self.provider = provider
+    }
+    
+    func fileManager(_ fileManager: FileManager, shouldCopyItemAt srcURL: URL, to dstURL: URL) -> Bool {
+        guard let provider = self.provider, let delegate = provider.fileOperationDelegate else {
+            return true
+        }
+        let srcPath = provider.relativePathOf(url: srcURL)
+        let dstPath = provider.relativePathOf(url: dstURL)
+        return delegate.fileProvider(provider, shouldDoOperation: .copy(source: srcPath, destination: dstPath))
+    }
+    
+    func fileManager(_ fileManager: FileManager, shouldMoveItemAt srcURL: URL, to dstURL: URL) -> Bool {
+        guard let provider = self.provider, let delegate = provider.fileOperationDelegate else {
+            return true
+        }
+        let srcPath = provider.relativePathOf(url: srcURL)
+        let dstPath = provider.relativePathOf(url: dstURL)
+        return delegate.fileProvider(provider, shouldDoOperation: .move(source: srcPath, destination: dstPath))
+    }
+    
+    func fileManager(_ fileManager: FileManager, shouldRemoveItemAt URL: URL) -> Bool {
+        guard let provider = self.provider, let delegate = provider.fileOperationDelegate else {
+            return true
+        }
+        let path = provider.relativePathOf(url: URL)
+        return delegate.fileProvider(provider, shouldDoOperation: .remove(path: path))
+    }
+    
+    func fileManager(_ fileManager: FileManager, shouldLinkItemAt srcURL: URL, to dstURL: URL) -> Bool {
+        guard let provider = self.provider, let delegate = provider.fileOperationDelegate else {
+            return true
+        }
+        let srcPath = provider.relativePathOf(url: srcURL)
+        let dstPath = provider.relativePathOf(url: dstURL)
+        return delegate.fileProvider(provider, shouldDoOperation: .link(link: srcPath, target: dstPath))
+    }
+    
+    func fileManager(_ fileManager: FileManager, shouldProceedAfterError error: Error, copyingItemAt srcURL: URL, to dstURL: URL) -> Bool {
+        guard let provider = self.provider, let delegate = provider.fileOperationDelegate else {
+            return false
+        }
+        let srcPath = provider.relativePathOf(url: srcURL)
+        let dstPath = provider.relativePathOf(url: dstURL)
+        return delegate.fileProvider(provider, shouldProceedAfterError: error, operation: .copy(source: srcPath, destination: dstPath))
+    }
+    
+    func fileManager(_ fileManager: FileManager, shouldProceedAfterError error: Error, movingItemAt srcURL: URL, to dstURL: URL) -> Bool {
+        guard let provider = self.provider, let delegate = provider.fileOperationDelegate else {
+            return false
+        }
+        let srcPath = provider.relativePathOf(url: srcURL)
+        let dstPath = provider.relativePathOf(url: dstURL)
+        return delegate.fileProvider(provider, shouldProceedAfterError: error, operation: .move(source: srcPath, destination: dstPath))
+    }
+    
+    func fileManager(_ fileManager: FileManager, shouldProceedAfterError error: Error, removingItemAt URL: URL) -> Bool {
+        guard let provider = self.provider, let delegate = provider.fileOperationDelegate else {
+            return false
+        }
+        let path = provider.relativePathOf(url: URL)
+        return delegate.fileProvider(provider, shouldProceedAfterError: error, operation: .remove(path: path))
+    }
+    
+    func fileManager(_ fileManager: FileManager, shouldProceedAfterError error: Error, linkingItemAt srcURL: URL, to dstURL: URL) -> Bool {
+        guard let provider = self.provider, let delegate = provider.fileOperationDelegate else {
+            return false
+        }
+        let srcPath = provider.relativePathOf(url: srcURL)
+        let dstPath = provider.relativePathOf(url: dstURL)
+        return delegate.fileProvider(provider, shouldProceedAfterError: error, operation: .link(link: srcPath, target: dstPath))
+    }
+}
+
+open class LocalOperationHandle: OperationHandle {
+    public let baseURL: URL
+    public let operationType: FileOperationType
+    
+    init (operationType: FileOperationType, baseURL: URL?) {
+        self.baseURL = baseURL ?? LocalFileProvider.defaultBaseURL()
+        self.operationType = operationType
+    }
+    
+    private var sourceURL: URL? {
+        guard let source = operationType.source else { return nil }
+        return source.hasPrefix("file://") ? URL(fileURLWithPath: source) : baseURL.appendingPathComponent(source)
+    }
+    
+    private var destURL: URL? {
+        guard let dest = operationType.destination else { return nil }
+        return dest.hasPrefix("file://") ? URL(fileURLWithPath: dest) : baseURL.appendingPathComponent(dest)
+    }
+    
+    /// Caution: may put pressure on CPU, may have latency
+    open var bytesSoFar: Int64 {
+        assert(!Thread.isMainThread, "Don't run \(#function) method on main thread")
+        switch operationType {
+        case .modify:
+            guard let url = sourceURL, url.isFileURL else { return 0 }
+            if url.fileIsDirectory {
+                return iterateDirectory(url, deep: true).totalsize
+            } else {
+                return url.fileSize
+            }
+        case .copy, .move:
+            guard let url = destURL, url.isFileURL else { return 0 }
+            if url.fileIsDirectory {
+                return iterateDirectory(url, deep: true).totalsize
+            } else {
+                return url.fileSize
+            }
+        default:
+            return 0
+        }
+        
+    }
+    
+    /// Caution: may put pressure on CPU, may have latency
+    open var totalBytes: Int64 {
+        assert(!Thread.isMainThread, "Don't run \(#function) method on main thread")
+        switch operationType {
+        case .copy, .move:
+            guard let url = sourceURL, url.isFileURL else { return 0 }
+            if url.fileIsDirectory {
+                return iterateDirectory(url, deep: true).totalsize
+            } else {
+                return url.fileSize
+            }
+        default:
+            return 0
+        }
+    }
+    
+    /// Not usable in local provider
+    open var inProgress: Bool {
+        return false
+    }
+    
+    /// Not usable in local provider
+    open func cancel() -> Bool{
+        return false
+    }
+    
+    func iterateDirectory(_ pathURL: URL, deep: Bool) -> (folders: Int, files: Int, totalsize: Int64) {
+        var folders = 0
+        var files = 0
+        var totalsize: Int64 = 0
+        let keys: [URLResourceKey] = [.isDirectoryKey, .fileSizeKey]
+        let enumOpt: FileManager.DirectoryEnumerationOptions = !deep ? [.skipsSubdirectoryDescendants, .skipsPackageDescendants] : []
+        
+        let fp = FileManager()
+        let filesList = fp.enumerator(at: pathURL, includingPropertiesForKeys: keys, options: enumOpt, errorHandler: nil)
+        while let fileURL = filesList?.nextObject() as? URL {
+            do {
+                let values = try fileURL.resourceValues(forKeys: [.isDirectoryKey, .fileSizeKey])
+                let isdir = values.isDirectory ?? false
+                let size = Int64(values.fileSize ?? 0)
+                if isdir {
+                    folders += 1
+                } else {
+                    files += 1
+                }
+                totalsize += size
+            } catch _ {
+            }
+        }
+        
+        return (folders, files, totalsize)
+        
+    }
+}
+
+internal extension URL {
+    var fileIsDirectory: Bool {
+        return (try? self.resourceValues(forKeys: [.isDirectoryKey]))?.isDirectory ?? false
+    }
+    
+    var fileSize: Int64 {
+        return Int64((try? self.resourceValues(forKeys: [.fileSizeKey]))?.fileSize ?? -1)
+    }
+    
+    var fileExists: Bool {
+        return self.isFileURL && FileManager.default.fileExists(atPath: self.path)
+    }
+}
@@ -12,14 +12,11 @@ open class RemoteOperationHandle: OperationHandle {
    
    internal var tasks: [Weak<URLSessionTask>]
    
-    private var _inProgress = false
-    open var inProgress: Bool {
-        return _inProgress
-    }
+    open private(set) var operationType: FileOperationType
    
-    init(tasks: [URLSessionTask]) {
+    init(operationType: FileOperationType, tasks: [URLSessionTask]) {
+        self.operationType = operationType
        self.tasks = tasks.map { Weak<URLSessionTask>($0) }
-        _inProgress = true
    }
    
    internal func add(task: URLSessionTask) {
@@ -30,12 +27,6 @@ open class RemoteOperationHandle: OperationHandle {
        self.tasks = tasks.filter { $0.value != nil }
    }
    
-    open var progress: Float {
-        let bytesSoFar = self.bytesSoFar
-        let totalBytes = self.totalBytes
-        return totalBytes > 0 ? Float(Double(bytesSoFar) / Double(totalBytes)) : Float.nan
-    }
-    
    open var bytesSoFar: Int64 {
        return tasks.reduce(0) {
            if let task = $1.value as? URLSessionUploadTask {
@@ -56,11 +47,17 @@ open class RemoteOperationHandle: OperationHandle {
        }
    }
    
-    open func cancel() {
+    open func cancel() -> Bool {
+        var canceled = false
        for taskbox in tasks {
            taskbox.value?.cancel()
+            canceled = true
        }
-        _inProgress = false
+        return canceled
+    }
+    
+    open var inProgress: Bool {
+        return tasks.reduce(false) { $0 || $1.value?.state ?? .canceling == .running }
    }
 }

@@ -12,12 +12,24 @@ import Foundation
 // For big-endian platforms like PowerPC, there must be a huge overhaul

 protocol SMBProtocolClientDelegate: class {
-    func receivedSMB2Response(_ header: SMB2.Header, response: SMBResponse)
+    func receivedResponse(client: SMB2ProtocolClient, response: SMBResponse, for: SMBRequest)
 }

 class SMB2ProtocolClient: FPSStreamTask {
-    var currentMessageID: UInt64 = 0
-    var sessionId: UInt64 = 0
+    var timeout: TimeInterval = 30
+    
+    private(set) var lastMessageID: UInt64 = 0
+    private(set) var sessionId: UInt64 = 0
+    private func messageId() -> UInt64 {
+        defer {
+            lastMessageID += 1
+        }
+        return lastMessageID
+    }
+    
+    private(set) var establishedTrees = Array<SMB2.TreeConnectResponse>()
+    private(set) var requestStack = [Int: SMBRequest]()
+    private(set) var responseStack = [Int: SMBResponse]()
    
    weak var delegate: SMBProtocolClientDelegate?
    
@@ -40,7 +52,7 @@ class SMB2ProtocolClient: FPSStreamTask {
        let data = createSMB2Message(header: smbHeader, message: msg)
        self.writeData(data, timeout: 0, completionHandler: { (e) in
            if self.sessionId == 0 {
-                self.readData(OfMinLength: 64, maxLength: 65536, timeout: 30, completionHandler: { (data, eof, e2) in
+                self.readData(OfMinLength: 64, maxLength: 65536, timeout: self.timeout, completionHandler: { (data, eof, e2) in
                    // TODO: set session id
                    completionHandler?(e2 ?? e)
                })
@@ -70,6 +82,7 @@ class SMB2ProtocolClient: FPSStreamTask {
        })
        return mId
    }
+    
    func sendTreeDisconnect(id treeId: UInt32, completionHandler: SimpleCompletionHandler) -> UInt64 {
        let mId = messageId()
        let smbHeader = SMB2.Header(command: .TREE_DISCONNECT, creditRequestResponse: 111, messageId: mId, treeId: treeId, sessionId: sessionId)
@@ -92,15 +105,13 @@ class SMB2ProtocolClient: FPSStreamTask {
        return mId
    }
    
-    func messageId() -> UInt64 {
-        defer {
-            currentMessageID += 1
-        }
-        return currentMessageID
+    func reset() {
+        
    }
-    
-    // MARK: create and analyse messages
-    
+}
+
+// MARK: create and analyse messages
+extension SMB2ProtocolClient {
    func determineSMBVersion(_ data: Data) -> Float {
        let smbverChar: Int8 = Int8(bitPattern: data.first ?? 0)
        let version = 0 - smbverChar
@@ -116,7 +127,7 @@ class SMB2ProtocolClient: FPSStreamTask {
            throw SMBFileProviderError.incompatibleHeader
        }
        let headersize = MemoryLayout<SMB1.Header>.size
-        let header: SMB1.Header = decode(data)
+        let header: SMB1.Header = data.scanValue()!
        var blocks = [(params: [UInt16], message: Data?)]()
        var offset = headersize
        while offset < data.count {
@@ -128,7 +139,7 @@ class SMB2ProtocolClient: FPSStreamTask {
            offset += MemoryLayout<UInt8>.size
            var rawParamWords = [UInt8](buffer[offset..<(offset + paramWordsCount * 2)])
            let paramData = Data(bytesNoCopy: UnsafeMutablePointer<UInt8>(&rawParamWords), count: rawParamWords.count, deallocator: .free)
-            paramWords = decode(paramData)
+            paramWords = paramData.scanValue()!
            offset += paramWordsCount * 2
            let messageBytesCount = Int(UInt16(buffer[0]) + UInt16(buffer[1]) << 8)
            offset += MemoryLayout<UInt16>.size
@@ -143,7 +154,7 @@ class SMB2ProtocolClient: FPSStreamTask {
        return (header, blocks)
    }
    
-    func digestSMB2Message(_ data: Data) throws -> (header: SMB2.Header, message: SMBResponse?)? {
+    func digestSMB2Message(_ data: Data) throws -> SMBResponse? {
        guard data.count > 65 else {
            throw URLError(.badServerResponse)
        }
@@ -154,7 +165,7 @@ class SMB2ProtocolClient: FPSStreamTask {
        let headerData = data.subdata(in: 0..<headersize)
        let messageSize = data.count - headersize
        let messageData = data.subdata(in: headersize..<(headersize + messageSize))
-        let header: SMB2.Header = decode(headerData)
+        let header: SMB2.Header = headerData.scanValue()!
        switch header.command {
        case .NEGOTIATE:
            return (header, SMB2.NegotiateResponse(data: messageData))
@@ -200,8 +211,7 @@ class SMB2ProtocolClient: FPSStreamTask {
    }
    
    func createSMBMessage(header: SMB1.Header, blocks: [(params: Data?, message: Data?)]) -> Data {
-        var headerv = header
-        var result = encode(&headerv)
+        var result = Data(value: header)
        for block in blocks {
            var paramWordsCount = UInt8(block.params?.count ?? 0)
            result.append(&paramWordsCount, count: MemoryLayout.size(ofValue: paramWordsCount))
@@ -218,9 +228,8 @@ class SMB2ProtocolClient: FPSStreamTask {
        return result
    }
    
-    func createSMB2Message(header: SMB2.Header, message: SMBRequest) -> Data {
-        var headerv = header
-        var result = encode(&headerv)
+    func createSMB2Message(header: SMB2.Header, message: SMBRequestBody) -> Data {
+        var result = Data(value: header)
        result.append(message.data())
        return result
    }
@@ -8,7 +8,7 @@

 import Foundation

-open class SMBFileProvider: FileProvider, FileProviderMonitor {
+class SMBFileProvider: FileProvider, FileProviderMonitor {
    open static var type: String = "Samba"
    open var isPathRelative: Bool = true
    open var baseURL: URL?
@@ -48,7 +48,7 @@ open class SMBFileProvider: FileProvider, FileProviderMonitor {
        return nil
    }
    
-    open func create(file fileAttribs: FileObject, at atPath: String, contents data: Data?, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
+    open func create(file fileName: String, at atPath: String, contents data: Data?, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
        NotImplemented()
        return nil
    }
@@ -108,6 +108,14 @@ open class SMBFileProvider: FileProvider, FileProviderMonitor {
    open func isRegisteredForNotification(path: String) -> Bool {
        return false
    }
+    
+    open func copy(with zone: NSZone? = nil) -> Any {
+        let copy = SMBFileProvider(baseURL: self.baseURL!, credential: self.credential!, afterInitialized: { _ in })!
+        copy.currentPath = self.currentPath
+        copy.delegate = self.delegate
+        copy.fileOperationDelegate = self.fileOperationDelegate
+        return copy
+    }
 }

 // MARK: basic CIFS interactivity
@@ -8,17 +8,35 @@

 import Foundation

-protocol SMBRequest {
+protocol SMBRequestBody {
    func data() -> Data
 }

-protocol SMBResponse {
+extension SMBRequestBody {
+    func data() -> Data {
+        return Data(value: self)
+    }
+}
+
+protocol SMBResponseBody {
    init? (data: Data)
 }

+extension SMBResponseBody {
+    init? (data: Data) {
+        if let v: Self = data.scanValue() {
+            self = v
+        } else {
+            return nil
+        }
+    }
+}

-protocol IOCtlRequestProtocol: SMBRequest {}
-protocol IOCtlResponseProtocol: SMBResponse {}
+typealias SMBRequest = (header: SMB2.Header, body: SMBRequestBody?)
+typealias SMBResponse = (header: SMB2.Header, body: SMBResponseBody?)
+
+protocol IOCtlRequestProtocol: SMBRequestBody {}
+protocol IOCtlResponseProtocol: SMBResponseBody {}


 struct SMBTime {
@@ -11,7 +11,7 @@ import Foundation
 extension SMB2 {
    // MARK: SMB2 Create
    
-    struct CreateRequest: SMBRequest {
+    struct CreateRequest: SMBRequestBody {
        let header: CreateRequest.Header
        let name: String?
        let contexts: [CreateContext]
@@ -40,7 +40,7 @@ extension SMB2 {
                header.contextLength = 0
                //result.appendData(nameData)
            }
-            var result = encode(&header)
+            var result = Data(value: header)
            result.append(body)
            return result
        }
@@ -158,7 +158,7 @@ extension SMB2 {
        }
    }
    
-    struct CreateResponse: SMBResponse {
+    struct CreateResponse: SMBResponseBody {
        struct Header {
            let size: UInt16
            fileprivate let _oplockLevel: UInt8
@@ -186,7 +186,7 @@ extension SMB2 {
            guard data.count >= MemoryLayout<CreateResponse.Header>.size else {
                return nil
            }
-            self.header = decode(data)
+            self.header = data.scanValue()!
            if self.header.contextsOffset > 0 {
                var contexts = [CreateContext]()
                var contextOffset = Int(self.header.contextsOffset) - MemoryLayout<SMB2.Header>.size
@@ -195,14 +195,9 @@ extension SMB2 {
                        self.contexts = contexts
                        return
                    }
-                    let contextDataHeader = data.subdata(in: contextOffset..<(contextOffset + MemoryLayout<CreateContext.Header>.size))
-                    if let lastContextHeader = CreateContext(data: contextDataHeader) {
-                        let lastContextLen = Int(lastContextHeader.header.dataOffset) + Int(lastContextHeader.header.dataLength) - contextOffset
-                        let lastContextData = data.subdata(in: contextOffset..<(contextOffset + lastContextLen))
-                        if let newContext = CreateContext(data: lastContextData) {
-                            contexts.append(newContext)
-                        }
-                        contextOffset = Int(lastContextHeader.header.next) - MemoryLayout<SMB2.Header>.size
+                    while contextOffset > 0, let context: CreateContext = data.scanValue(start: contextOffset) {
+                        contexts.append(context)
+                        contextOffset = Int(context.header.next) - MemoryLayout<SMB2.Header>.size
                    }
                }
                self.contexts = contexts
@@ -232,9 +227,8 @@ extension SMB2 {
        }
        
        init(name: UUID, data: Data) {
-            var uuid = uuid_t(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
-            (name as NSUUID).getBytes(&uuid.0)
-            var nameData = Data(bytes: &uuid.0, count: 16)
+            let uuid = name.uuid
+            var nameData = Data(value: uuid)
            self.header = CreateContext.Header(next: 0, nameOffset: 32, nameLength: UInt16(nameData.count), reserved: 0, dataOffset: UInt16(nameData.count), dataLength: UInt32(data.count))
            self.buffer = data
        }
@@ -244,12 +238,12 @@ extension SMB2 {
            guard data.count > headersize else {
                return nil
            }
-            self.header = decode(data)
+            self.header = data.scanValue()!
            self.buffer = data.subdata(in: headersize..<data.count)
        }
        
        func data() -> Data {
-            var result = encode(header)
+            var result = Data(value: header)
            result.append(buffer)
            return result
        }
@@ -363,7 +357,7 @@ extension SMB2 {
    
    // MARK: SMB2 Close
    
-    struct CloseRequest: SMBRequest {
+    struct CloseRequest: SMBRequestBody {
        let size: UInt16
        let flags: CloseFlags
        fileprivate let reserved2: UInt32
@@ -377,13 +371,9 @@ extension SMB2 {
            self.flags = []
            self.reserved2 = 0
        }
-        
-        func data() -> Data {
-            return encode(self)
-        }
    }
    
-    struct CloseResponse: SMBResponse {
+    struct CloseResponse: SMBResponseBody {
        let size: UInt16
        let flags: CloseFlags
        fileprivate let reserved: UInt32
@@ -394,10 +384,6 @@ extension SMB2 {
        let allocationSize: UInt64
        let endOfFile: UInt64
        let fileAttributes: FileAttributes
-        
-        init? (data: Data) {
-            self = decode(data)
-        }
    }
    
    struct CloseFlags: OptionSet {
@@ -412,7 +398,7 @@ extension SMB2 {
    
    // MARK: SMB2 Flush
    
-    struct FlushRequest: SMBRequest {
+    struct FlushRequest: SMBRequestBody {
        let size: UInt16
        fileprivate let reserved: UInt16
        fileprivate let reserved2: UInt32
@@ -426,13 +412,9 @@ extension SMB2 {
            self.reserved = 0
            self.reserved2 = 0
        }
-        
-        func data() -> Data {
-            return encode(self)
-        }
    }
    
-    struct FlushResponse: SMBResponse {
+    struct FlushResponse: SMBResponseBody {
        let size: UInt16
        let reserved: UInt16
        
@@ -440,9 +422,5 @@ extension SMB2 {
            self.size = 4
            self.reserved = 0
        }
-        
-        init? (data: Data) {
-            self = decode(data)
-        }
    }
 }
@@ -11,7 +11,7 @@ import Foundation
 extension SMB2 {
    // MARK: SMB2 Read
    
-    struct ReadRequest: SMBRequest {
+    struct ReadRequest: SMBRequestBody {
        let size: UInt16
        fileprivate let padding: UInt8
        let flags: ReadRequest.Flags
@@ -43,10 +43,6 @@ extension SMB2 {
            self.channelBuffer = 0
        }
        
-        func data() -> Data {
-            return encode(read)
-        }
-        
        struct Flags: OptionSet {
            let rawValue: UInt8
            
@@ -58,7 +54,7 @@ extension SMB2 {
        }
    }
    
-    struct ReadRespone: SMBResponse {
+    struct ReadRespone: SMBResponseBody {
        struct Header {
            let size: UInt16
            let offset: UInt8
@@ -75,7 +71,7 @@ extension SMB2 {
            guard data.count > 16 else {
                return nil
            }
-            self.header = decode(data)
+            self.header = data.scanValue()!
            let headersize = MemoryLayout<Header>.size
            self.buffer = data.subdata(in: headersize..<data.count)
        }
@@ -89,7 +85,7 @@ extension SMB2 {
    
    // MARK: SMB2 Write
    
-    struct WriteRequest: SMBRequest {
+    struct WriteRequest: SMBRequestBody {
        let header: WriteRequest.Header
        let channelInfo: ChannelInfo?
        let fileData: Data
@@ -124,7 +120,7 @@ extension SMB2 {
        }
        
        func data() -> Data {
-            var result = encode(self.header)
+            var result = Data(value: self.header)
            if let channelInfo = channelInfo {
                result.append(channelInfo.data())
            }
@@ -144,41 +140,29 @@ extension SMB2 {
        }
    }
    
-    struct WriteResponse: SMBResponse {
+    struct WriteResponse: SMBResponseBody {
        let size: UInt16
        fileprivate let reserved: UInt16
        let writtenBytes: UInt32
        fileprivate let remaining: UInt32
        fileprivate let channelInfoOffset: UInt16
        fileprivate let channelInfoLength: UInt16
-        
-        init?(data: Data) {
-            self = decode(data)
-        }
    }
    
-    struct ChannelInfo: SMBRequest {
+    struct ChannelInfo: SMBRequestBody {
        let offset: UInt64
        let token: UInt32
        let length: UInt32
-        
-        func data() -> Data {
-            return encode(data)
-        }
    }
    
    // MARK: SMB2 Lock
    
-    struct LockElement: SMBRequest {
+    struct LockElement: SMBRequestBody {
        let offset: UInt64
        let length: UInt64
        let flags: LockElement.Flags
        fileprivate let reserved: UInt32
        
-        func data() -> Data {
-            return encode(self)
-        }
-        
        struct Flags: OptionSet {
            let rawValue: UInt32
            
@@ -193,7 +177,7 @@ extension SMB2 {
        }
    }
    
-    struct LockRequest: SMBRequest {
+    struct LockRequest: SMBRequestBody {
        let header: LockRequest.Header
        let locks: [LockElement]
        
@@ -203,9 +187,9 @@ extension SMB2 {
        }
        
        func data() -> Data {
-            var result = encode(header)
+            var result = Data(value: header)
            for lock in locks {
-                result.append(encode(lock))
+                result.append(Data(value: lock))
            }
            return result
        }
@@ -218,7 +202,7 @@ extension SMB2 {
        }
    }
    
-    struct LockResponse: SMBResponse {
+    struct LockResponse: SMBResponseBody {
        let size: UInt16
        let reserved: UInt16
        
@@ -226,15 +210,11 @@ extension SMB2 {
            self.size = 4
            self.reserved = 0
        }
-        
-        init? (data: Data) {
-            self = decode(data)
-        }
    }
    
    // MARK: SMB2 Cancel
    
-    struct CancelRequest: SMBRequest {
+    struct CancelRequest: SMBRequestBody {
        let size: UInt16
        let reserved: UInt16
        
@@ -242,9 +222,5 @@ extension SMB2 {
            self.size = 4
            self.reserved = 0
        }
-        
-        func data() -> Data {
-            return encode(self)
-        }
    }
 }
@@ -15,7 +15,7 @@ extension SMB2 {
     * IOCtl usage is usually limited in SMB to pipe requests and duplicating file inside server
     */
    
-    struct IOCtlRequest: SMBRequest {
+    struct IOCtlRequest: SMBRequestBody {
        let header: Header
        let requestData:  IOCtlRequestProtocol?
        
@@ -26,7 +26,7 @@ extension SMB2 {
        }
        
        func data() -> Data {
-            var result = encode(self.header)
+            var result = Data(value: self.header)
            if let reqData = requestData?.data() {
                result.append(reqData)
            }
@@ -63,12 +63,12 @@ extension SMB2 {
        }
    }
    
-    struct IOCtlResponse: SMBResponse {
+    struct IOCtlResponse: SMBResponseBody {
        let header: Header
        let responseData:  IOCtlResponseProtocol?
        
        init?(data: Data) {
-            self.header = decode(data)
+            self.header = data.scanValue()!
            let endRange = Int(self.header.outputOffset - 64) + Int(self.header.outputCount)
            let response = data.subdata(in: Int(self.header.outputOffset - 64)..<endRange)
            switch self.header.ctlCode {
@@ -140,10 +140,10 @@ extension SMB2 {
            let chunks: [Chunk]
            
            func data() -> Data {
-                var result = encode(sourceKey)
-                result.append(encode(chunkCount))
-                var reserved: UInt32 = 0
-                result.append(encode(&reserved))
+                var result = Data(value: sourceKey)
+                result.append(Data(value: chunkCount))
+                let reserved: UInt32 = 0
+                result.append(Data(value: reserved))
                return Data()
            }
            
@@ -152,10 +152,6 @@ extension SMB2 {
                let targetOffset: UInt64
                let length: UInt32
                fileprivate let reserved: UInt32
-                
-                func data() -> Data {
-                    return encode(self)
-                }
            }
        }
        
@@ -182,10 +178,6 @@ extension SMB2 {
                self.length = length
                self.offset = offset
            }
-            
-            func data() -> Data {
-                return encode(self)
-            }
        }
        
        struct ResilencyRequest: IOCtlRequestProtocol {
@@ -197,10 +189,6 @@ extension SMB2 {
                self.timeout = timeout
                self.reserved = 0
            }
-            
-            func data() -> Data {
-                return encode(self)
-            }
        }
        
        struct ValidateNegotiateInfo: IOCtlRequestProtocol {
@@ -213,8 +201,8 @@ extension SMB2 {
            }
            
            func data() -> Data {
-                var result = encode(self.header)
-                dialects.forEach { result.append(encode($0)) }
+                var result = Data(value: self.header)
+                dialects.forEach { result.append(Data(value: $0)) }
                return result
            }
            
@@ -234,10 +222,6 @@ extension SMB2 {
            let chunksCount: UInt32
            let chunksBytesWritten: UInt32
            let totalBytesWriiten: UInt32
-            
-            init?(data: Data) {
-                self = decode(data)
-            }
        }
        
        // SRV_ENUMERATE_SNAPSHOTS
@@ -247,8 +231,9 @@ extension SMB2 {
            let snapshots: [SMBTime]
            
            init?(data: Data) {
-                self.count = decode(data)
-                self.returnedCount = decode(data.subdata(in: 4..<8))
+                guard data.count > 8 else { return nil }
+                self.count = data.scanValue()!
+                self.returnedCount = data.scanValue(start: 4)!
                //let size: UInt32 = decode(data.subdataWithRange(NSRange(location: 8, length: 4)))
                var snapshots = [SMBTime]()
                let dateFormatter = DateFormatter()
@@ -258,7 +243,7 @@ extension SMB2 {
                    if data.count < offset + 48 {
                        return nil
                    }
-                    let datestring = String(data: data.subdata(in: offset..<(offset + 48)), encoding: .utf16)
+                    let datestring = data.scanString(start: offset, length: 48, encoding: .utf16)
                    if let datestring = datestring, let date = dateFormatter.date(from: datestring) {
                        snapshots.append(SMBTime(date: date))
                    }
@@ -271,32 +256,21 @@ extension SMB2 {
            let key: (UInt64, UInt64, UInt64)
            fileprivate let contextLength: UInt32
            fileprivate let context: UInt32
-            
-            init?(data: Data) {
-                self = decode(data)
-            }
        }
        
        struct ReadHash: IOCtlResponseProtocol {
            // TODO: Implement IOCTL READ_HASH
-            
-            init?(data: Data) {
-                self = decode(data)
-            }
        }
        
        struct NetworkInterfaceInfo: IOCtlResponseProtocol {
            let items: [NetworkInterfaceInfo.Item]
            
            init?(data: Data) {
-                let count = data.count / MemoryLayout<Item>.size
-                guard count > 0 else {
-                    return nil
-                }
                var items = [Item]()
-                for i in 0..<count {
-                    let itemdata = data.subdata(in: (i * MemoryLayout<Item>.size)..<((i + 1) * MemoryLayout<Item>.size))
-                    items.append(decode(itemdata))
+                var offset = 0
+                while let item: Item = data.scanValue(start: offset) {
+                    items.append(item)
+                    offset += MemoryLayout<Item>.size
                }
                self.items = items
            }
@@ -335,15 +309,11 @@ extension SMB2 {
                static let ipv6: sa_family_t = 0x17
                
                var sockaddr: sockaddr_in {
-                    var sockaddrStorage = self.sockaddrStorage
-                    let data = Data(bytes: &sockaddrStorage, count: 16)
-                    return decode(data)
+                    return Data.mapMemory(from: self.sockaddrStorage)!
                }
                
                var sockaddr6: sockaddr_in6 {
-                    var sockaddrStorage = self.sockaddrStorage
-                    let data = Data(bytes: &sockaddrStorage, count: 28)
-                    return decode(data)
+                     return Data.mapMemory(from: self.sockaddrStorage)!
                }
            }
        }
@@ -356,10 +326,6 @@ extension SMB2 {
            var dialect: (major: Int, minor: Int) {
                return (major: Int(_dialect & 0xFF), minor: Int(_dialect >> 8))
            }
-            
-            init?(data: Data) {
-                self = decode(data)
-            }
        }
    }
    
@@ -11,7 +11,7 @@ import Foundation
 extension SMB2 {
    // MARK: SMB2 Change Notify
    
-    struct ChangeNotifyRequest: SMBRequest {
+    struct ChangeNotifyRequest: SMBRequestBody {
        let size: UInt16
        let flags: ChangeNotifyRequest.Flags
        let outputBufferLength: UInt32
@@ -28,10 +28,6 @@ extension SMB2 {
            self.reserved = 0
        }
        
-        func data() -> Data {
-            return encode(self)
-        }
-        
        struct Flags: OptionSet {
            let rawValue: UInt16
            
@@ -79,7 +75,7 @@ extension SMB2 {
        }
    }
    
-    struct ChangeNotifyResponse: SMBResponse {
+    struct ChangeNotifyResponse: SMBResponseBody {
        let notifications: [(action: FileNotifyAction, fileName: String)]
        
        init?(data: Data) {
@@ -89,19 +85,14 @@ extension SMB2 {
            
            var offset = 0
            while i < maxLoop {
-                let nextOffsetData = data.subdata(in: offset..<(offset + 4))
-                let nextOffset: UInt32 = decode(nextOffsetData)
-                
-                let actionData = data.subdata(in: (offset + 4)..<(offset + 8))
-                let actionValue: UInt32 = decode(actionData)
+                let nextOffset: UInt32 = data.scanValue(start: offset) ?? 0
+                let actionValue: UInt32 = data.scanValue(start: offset + 4) ?? 0
                guard let action = FileNotifyAction(rawValue: actionValue) else {
                    continue
                }
                
-                let fileLenData = data.subdata(in: (offset + 8)..<(offset + 12))
-                let fileNameLen = Int(decode(fileLenData) as UInt32)
-                let fileNameData = data.subdata(in: (offset + 12)..<(offset + 12 + fileNameLen))
-                let fileName = String(data: fileNameData, encoding: .utf16) ?? ""
+                let fileNameLen = Int(data.scanValue(start: offset + 8) as UInt32? ?? 0)
+                let fileName = data.scanString(start: offset + 12, length: fileNameLen, encoding: .utf16) ?? ""
                result.append((action: action, fileName: fileName))
                
                offset += Int(nextOffset)
@@ -11,7 +11,7 @@ import Foundation
 extension SMB2 {
    // MARK: SMB2 Query Directory
    
-    struct QueryDirectoryRequest: SMBRequest {
+    struct QueryDirectoryRequest: SMBRequestBody {
        let header: QueryDirectoryRequest.Header
        let searchPattern: String?
        
@@ -28,7 +28,7 @@ extension SMB2 {
        }
        
        func data() -> Data {
-            var result = encode(header)
+            var result = Data(value: header)
            if let patternData = searchPattern?.data(using: .utf16) {
                result.append(patternData)
            }
@@ -60,7 +60,7 @@ extension SMB2 {
        }
    }
    
-    struct QueryDirectoryResponse: SMBResponse {
+    struct QueryDirectoryResponse: SMBResponseBody {
        let buffer: Data
        
        func parseAs(type: FileInformationEnum) -> [(header: SMB2FilesInformationHeader, fileName: String)] {
@@ -68,43 +68,24 @@ extension SMB2 {
            var result = [(header: SMB2FilesInformationHeader, fileName: String)]()
            while true {
                let header: SMB2FilesInformationHeader
-                let headersize: Int
                switch type {
                case .fileDirectoryInformation:
-                    headersize = MemoryLayout<FileDirectoryInformationHeader>.size
-                    let headerData = buffer.subdata(in: offset..<(offset + headersize))
-                    let h: FileDirectoryInformationHeader = decode(headerData)
-                    header = h
+                    header = buffer.scanValue(start: offset) as FileDirectoryInformationHeader!
                case .fileFullDirectoryInformation:
-                    headersize = MemoryLayout<FileFullDirectoryInformationHeader>.size
-                    let headerData = buffer.subdata(in: offset..<(offset + headersize))
-                    let h: FileFullDirectoryInformationHeader = decode(headerData)
-                    header = h
+                    header = buffer.scanValue(start: offset) as FileFullDirectoryInformationHeader!
                case .fileIdFullDirectoryInformation:
-                    headersize = MemoryLayout<FileIdFullDirectoryInformationHeader>.size
-                    let headerData = buffer.subdata(in: offset..<(offset + headersize))
-                    let h: FileIdFullDirectoryInformationHeader = decode(headerData)
-                    header = h
+                    header = buffer.scanValue(start: offset) as FileIdFullDirectoryInformationHeader!
                case .fileBothDirectoryInformation:
-                    headersize = MemoryLayout<FileBothDirectoryInformationHeader>.size
-                    let headerData = buffer.subdata(in: offset..<(offset + headersize))
-                    let h: FileBothDirectoryInformationHeader = decode(headerData)
-                    header = h
+                    header = buffer.scanValue(start: offset) as FileBothDirectoryInformationHeader!
                case .fileIdBothDirectoryInformation:
-                    headersize = MemoryLayout<FileIdBothDirectoryInformationHeader>.size
-                    let headerData = buffer.subdata(in: offset..<(offset + headersize))
-                    let h: FileIdBothDirectoryInformationHeader = decode(headerData)
-                    header = h
+                    header = buffer.scanValue(start: offset) as FileIdBothDirectoryInformationHeader!
                case .fileNamesInformation:
-                    headersize = MemoryLayout<FileNamesInformationHeader>.size
-                    let headerData = buffer.subdata(in: offset..<(offset + headersize))
-                    let h: FileNamesInformationHeader = decode(headerData)
-                    header = h
+                    header = buffer.scanValue(start: offset) as FileNamesInformationHeader!
                default:
                    return []
                }
-                let fnData = buffer.subdata(in: (offset + headersize)..<(offset + headersize + Int(header.fileNameLength)))
-                let fileName = String(data: fnData, encoding: .utf16) ?? ""
+                let headersize = MemoryLayout.size(ofValue: header)
+                let fileName = buffer.scanString(start: headersize, length: Int(header.fileNameLength), encoding: .utf16) ?? ""
                result.append((header: header, fileName: fileName))
                if header.nextEntryOffset == 0 {
                    break
@@ -115,8 +96,8 @@ extension SMB2 {
        }
        
        init? (data: Data) {
-            let offset = Int(decode(data.subdata(in: 2..<4)) as UInt16)
-            let length = Int(decode(data.subdata(in: 4..<8)) as UInt32)
+            let offset = Int(data.scanValue(start: 2) as UInt16!)
+            let length = Int(data.scanValue(start: 4) as UInt32!)
            guard data.count > offset + length else {
                return nil
            }
@@ -126,7 +107,7 @@ extension SMB2 {
    
    // MARK: SMB2 Query Info
    
-    struct QueryInfoRequest: SMBRequest {
+    struct QueryInfoRequest: SMBRequestBody {
        let header: Header
        let buffer: Data?
        
@@ -143,8 +124,8 @@ extension SMB2 {
                }
                let strLength = UInt8(strData.count)
                let nextOffset = UInt32(4 + 1 + strData.count)
-                var data = encode(nextOffset)
-                data.append(encode(strLength))
+                var data = Data(value: nextOffset)
+                data.append(Data(value: strLength))
                data.append(strData)
                data.count += 1
                let padSize = (data.count) % 4
@@ -170,8 +151,7 @@ extension SMB2 {
        // TODO: Implement QUOTA_INFO init
        
        func data() -> Data {
-            let headerData = encode(header)
-            var result = headerData
+            var result = Data(value: header)
            if let buffer = buffer {
                result.append(buffer)
            }
@@ -204,12 +184,11 @@ extension SMB2 {
        }
    }
    
-    struct QueryInfoResponse: SMBResponse {
+    struct QueryInfoResponse: SMBResponseBody {
        let buffer: Data
        
        init?(data: Data) {
-            let structSizeData = data.subdata(in: 0..<2)
-            let structSize: UInt16 = decode(structSizeData)
+            let structSize: UInt16 = data.scanValue()!
            guard structSize == 9 else {
                return nil
            }
@@ -217,10 +196,9 @@ extension SMB2 {
            /*let offsetData = data.subdataWithRange(NSRange(location: 2, length: 2))
            let offset: UInt16 = decode(offsetData)*/
            
-            let lengthData = data.subdata(in: 4..<8)
-            let length = Int(decode(lengthData) as UInt32)
+            let length = Int(data.scanValue(start: 4) as UInt32!)
            
-            guard data.count >= 8 + Int(length) else {
+            guard data.count >= 8 + length else {
                return nil
            }
            
@@ -228,40 +206,38 @@ extension SMB2 {
        }
        
        var asAccessInformation: FileAccessInformation {
-            return decode(buffer)
+            return buffer.scanValue()!
        }
        
        var asAlignmentInformation: FileAlignmentInformation {
-            return decode(buffer)
+            return buffer.scanValue()!
        }
        
        var asAllInformation: (header: FileAllInformationHeader, name: String) {
-            let header: FileAllInformationHeader = decode(buffer)
+            let header: FileAllInformationHeader = buffer.scanValue()!
            let headersize = MemoryLayout<FileAllInformationHeader>.size
-            let nameData = buffer.subdata(in: headersize..<(headersize + Int(header.nameLength)))
-            let name = String(data: nameData, encoding: .utf16) ?? ""
+            let name = buffer.scanString(start: headersize, length: Int(header.nameLength), encoding: .utf16) ?? ""
            return (header, name)
        }
        
        var asAlternateNameInformation: String {
-            let b = (buffer as NSData).bytes.bindMemory(to: CChar.self, capacity: buffer.count)
-            return String(cString: b, encoding: .utf16) ?? ""
+            return buffer.scanString(start: 0, length: buffer.count, encoding: .utf16) ?? ""
        }
        
        var asAttributeTagInformation: FileAttributeTagInformation {
-            return decode(buffer)
+            return buffer.scanValue()!
        }
        
        var asBasicInformation: FileBasicInformation {
-            return decode(buffer)
+            return buffer.scanValue()!
        }
        
        var asCompressionInformation: FileCompressionInformation {
-            return decode(buffer)
+            return buffer.scanValue()!
        }
        
        var asEaInformation: FileEaInformation {
-            return decode(buffer)
+            return buffer.scanValue()!
        }
        
        var asFullEaInformation: FileFullEaInformation {
@@ -270,83 +246,80 @@ extension SMB2 {
        }
        
        var asInternalInformation: FileInternalInformation {
-            return decode(buffer)
+            return buffer.scanValue()!
        }
        
        var asModeInformation: FileModeInformation {
-            return decode(buffer)
+            return buffer.scanValue()!
        }
        
        var asNetworkOpenInformation: FileNetworkOpenInformation {
-            return decode(buffer)
+            return buffer.scanValue()!
        }
        
        var asPipeInformation: FilePipeInformation {
-            return decode(buffer)
+            return buffer.scanValue()!
        }
        
        var asPipeLocalInformation: FilePipeLocalInformation {
-            return decode(buffer)
+            return buffer.scanValue()!
        }
        
        var asPipeRemoteInformation: FilePipeRemoteInformation {
-            return decode(buffer)
+            return buffer.scanValue()!
        }
        
        var asPositionInformation: FilePositionInformation {
-            return decode(buffer)
+            return buffer.scanValue()!
        }
        
        var asStandardInformation: FileStandardInformation {
-            return decode(buffer)
+            return buffer.scanValue()!
        }
        
        var asStreamInformation: (header: FileStreamInformationHeader, name: String) {
-            let header: FileStreamInformationHeader = decode(buffer)
+            let header: FileStreamInformationHeader = buffer.scanValue()!
            let headersize = MemoryLayout<FileStreamInformationHeader>.size
-            let nameData = buffer.subdata(in: headersize..<(headersize + Int(header.streamNameLength)))
-            let name = String(data: nameData, encoding: .utf16) ?? ""
+            let name = buffer.scanString(start: headersize, length: Int(header.streamNameLength), encoding: .utf16) ?? ""
            return (header, name)
        }
        
        var asFsVolumeInformation: (header: FileFsVolumeInformationHeader, name: String) {
-            let header: FileFsVolumeInformationHeader = decode(buffer)
+            let header: FileFsVolumeInformationHeader = buffer.scanValue()!
            let headersize = MemoryLayout<FileFsVolumeInformationHeader>.size
-            let nameData = buffer.subdata(in: headersize..<(headersize + Int(header.labelLength)))
-            let name = String(data: nameData, encoding: .utf16) ?? ""
+            let name = buffer.scanString(start: headersize, length: Int(header.labelLength), encoding: .utf16) ?? ""
            return (header, name)
        }
        
        var asFsSizeInformation: FileFsSizeInformation {
-            return decode(buffer)
+            return buffer.scanValue()!
        }
        
        var asFsDeviceInformation: FileFsDeviceInformation {
-            return decode(buffer)
+            return buffer.scanValue()!
        }
        
        var asFsAttributeInformation: (header: FileFsAttributeInformationHeader, name: String) {
-            let header: FileFsAttributeInformationHeader = decode(buffer)
+            let header: FileFsAttributeInformationHeader = buffer.scanValue()!
            let headersize = MemoryLayout<FileFsAttributeInformationHeader>.size
-            let nameData = buffer.subdata(in: headersize..<(headersize + Int(header.nameLength)))
-            let name = String(data: nameData, encoding: .utf16) ?? ""
+            let name = buffer.scanString(start: headersize, length: Int(header.nameLength), encoding: .utf16) ?? ""
            return (header, name)
        }
        
        var asFsControlInformation: FileFsControlInformation {
-            return decode(buffer)
+            return buffer.scanValue()!
        }
        
        var asFsFullSizeInformation: FileFsFullSizeInformation {
-            return decode(buffer)
+            return buffer.scanValue()!
        }
        
        var asFsObjectIdInformation: FileFsObjectIdInformation {
-            return decode(buffer)
+            return buffer.scanValue()!
        }
        
        var asFsSectorSizeInformation: FileFsSectorSizeInformation {
-            return decode(buffer)
+            return buffer.scanValue()!
        }
    }
 }
@@ -8,7 +8,7 @@

 import Foundation

-protocol SMB2FilesInformationHeader: SMBResponse {
+protocol SMB2FilesInformationHeader: SMBResponseBody {
    var nextEntryOffset: UInt32 { get }
    var fileIndex: UInt32 { get }
    var fileNameLength : UInt32 { get }
@@ -127,10 +127,6 @@ extension SMB2 {
        let allocationSize: UInt64
        let fileAttributes: FileAttributes
        let fileNameLength : UInt32
-        
-        init?(data: Data) {
-            self = decode(data)
-        }
    }
    
    struct FileFullDirectoryInformationHeader: SMB2FilesInformationHeader {
@@ -145,10 +141,6 @@ extension SMB2 {
        let fileAttributes: FileAttributes
        let fileNameLength : UInt32
        let extendedAttributesSize: UInt32
-        
-        init?(data: Data) {
-            self = decode(data)
-        }
    }
    
    struct FileIdFullDirectoryInformationHeader: SMB2FilesInformationHeader {
@@ -165,10 +157,6 @@ extension SMB2 {
        let extendedAttributesSize: UInt32
        fileprivate let reserved: UInt32
        let fileId: FileId
-        
-        init?(data: Data) {
-            self = decode(data)
-        }
    }
    
    struct FileBothDirectoryInformationHeader: SMB2FilesInformationHeader {
@@ -187,14 +175,9 @@ extension SMB2 {
        fileprivate let reserved: UInt8
        fileprivate let _shortName: FileShortNameType
        var shortName: String? {
-            let s = encode(_shortName)
-            var d = s
-            d.count = Int(shortNameLen)
-            return String(data: d, encoding: .utf16)
-        }
-        
-        init?(data: Data) {
-            self = decode(data)
+            var data = Data(value: _shortName)
+            data.count = Int(shortNameLen)
+            return String(data: data, encoding: .utf16)
        }
    }
    
@@ -214,27 +197,18 @@ extension SMB2 {
        fileprivate let reserved: UInt8
        fileprivate let _shortName: FileShortNameType
        var shortName: String? {
-            let s = encode(_shortName)
-            var d = s
-            d.count = Int(shortNameLen)
-            return String(data: d, encoding: .utf16)
+            var data = Data(value: _shortName)
+            data.count = Int(shortNameLen)
+            return String(data: data, encoding: .utf16)
        }
        fileprivate let reserved2: UInt16
        let fileId : FileId
-        
-        init?(data: Data) {
-            self = decode(data)
-        }
    }
    
    struct FileNamesInformationHeader: SMB2FilesInformationHeader {
        let nextEntryOffset: UInt32
        let fileIndex: UInt32
        let fileNameLength : UInt32
-        
-        init?(data: Data) {
-            self = decode(data)
-        }
    }
    
    typealias FileShortNameType = (UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8,
@@ -11,7 +11,7 @@ import Foundation
 extension SMB2 {
    // MARK: SMB2 Negotiating
    
-    struct NegotiateRequest: SMBRequest {
+    struct NegotiateRequest: SMBRequestBody {
        let header: NegotiateRequest.Header
        let dialects: [UInt16]
        let contexts: [(type: NegotiateContextType, data: Data)]
@@ -43,13 +43,11 @@ extension SMB2 {
            
            var contextData = Data()
            for context in contexts {
-                var contextType = context.type.rawValue
-                contextData.append(UnsafeBufferPointer(start: &contextType, count: 2))
-                var dataLen = UInt16(context.data.count)
+                contextData.append(Data(value: context.type.rawValue))
                contextData.count += 4
-                contextData.append(UnsafeBufferPointer(start: &dataLen, count: 2))
+                contextData.append(Data(value: UInt16(context.data.count)))
            }
-            var result = encode(&header)
+            var result = Data(value: header)
            result.append(dialectData as Data)
            result.append(contextData as Data)
            return result
@@ -91,16 +89,16 @@ extension SMB2 {
        }
    }
    
-    struct NegotiateResponse: SMBResponse {
+    struct NegotiateResponse: SMBResponseBody {
        let header: NegotiateResponse.Header
        let buffer: Data?
        let contexts: [(type: NegotiateContextType, data: Data)]
        
        init? (data: Data) {
-            if data.count < 64 {
+            guard data.count >= 64 else {
                return nil
            }
-            self.header = decode(data)
+            self.header = data.scanValue()!
            if Int(header.size) != 65 {
                return nil
            }
@@ -176,7 +174,7 @@ extension SMB2 {
    
    // MARK: SMB2 Session Setup
    
-    struct SessionSetupRequest: SMBRequest {
+    struct SessionSetupRequest: SMBRequestBody {
        let header: SessionSetupRequest.Header
        let buffer: Data?
        
@@ -194,7 +192,7 @@ extension SMB2 {
            var header = self.header
            header.bufferOffset = UInt16(MemoryLayout<SMB2.Header>.size + MemoryLayout<SessionSetupRequest.Header>.size)
            header.bufferLength = UInt16(buffer?.count ?? 0)
-            var result = encode(&header)
+            var result = Data(value: header)
            if let buffer = self.buffer {
                result.append(buffer)
            }
@@ -235,15 +233,15 @@ extension SMB2 {
        }
    }
    
-    struct SessionSetupResponse: SMBResponse {
+    struct SessionSetupResponse: SMBResponseBody {
        let header: SessionSetupResponse.Header
        let buffer: Data?
        
        init? (data: Data) {
-            if data.count < 64 {
+            guard data.count >= 64 else {
                return nil
            }
-            self.header = decode(data)
+            self.header = data.scanValue()!
            if Int(header.size) != 9 {
                return nil
            }
@@ -289,7 +287,7 @@ extension SMB2 {
    
    // MARK: SMB2 Log off
    
-    struct LogOff: SMBRequest, SMBResponse {
+    struct LogOff: SMBRequestBody, SMBResponseBody {
        let size: UInt16
        let reserved: UInt16
        
@@ -297,19 +295,11 @@ extension SMB2 {
            self.size = 4
            self.reserved = 0
        }
-        
-        init? (data: Data) {
-            self = decode(data)
-        }
-        
-        func data() -> Data {
-            return encode(self)
-        }
    }
    
    // MARK: SMB2 Echo
    
-    struct Echo: SMBRequest, SMBResponse {
+    struct Echo: SMBRequestBody, SMBResponseBody {
        let size: UInt16
        let reserved: UInt16
        
@@ -317,13 +307,5 @@ extension SMB2 {
            self.size = 4
            self.reserved = 0
        }
-        
-        init? (data: Data) {
-            self = decode(data)
-        }
-        
-        func data() -> Data {
-            return encode(self)
-        }
    }
 }
@@ -10,14 +10,14 @@ import Foundation

 extension SMB2 {
    // MARK: SMB2 Set Info
-    struct SetInfoRequest: SMBRequest {
+    struct SetInfoRequest: SMBRequestBody {
        let header: Header
        let buffer: Data?
        
-        
-        
        func data() -> Data {
-            return Data()
+            var result = Data(value: header)
+            result.append(buffer ?? Data())
+            return result 
        }
        
        struct Header {
@@ -32,15 +32,11 @@ extension SMB2 {
        }
    }
    
-    struct SetInfoResponse: SMBResponse {
+    struct SetInfoResponse: SMBResponseBody {
        let size: UInt16
        
        init() {
            self.size = 2
        }
-        
-        init? (data: Data) {
-            self = decode(data)
-        }
    }
 }
@@ -11,7 +11,7 @@ import Foundation
 extension SMB2 {
    // MARK: SMB2 Tree Connect
    
-    struct TreeConnectRequest: SMBRequest {
+    struct TreeConnectRequest: SMBRequestBody {
        let header: TreeConnectRequest.Header
        let buffer: Data?
        var path: String {
@@ -34,7 +34,7 @@ extension SMB2 {
            var header = self.header
            header.pathOffset = UInt16(MemoryLayout<SMB2.Header>.size + MemoryLayout<TreeConnectRequest.Header>.size)
            header.pathLength = UInt16(buffer?.count ?? 0)
-            var result = encode(&header)
+            var result = Data(value: header)
            if let buffer = self.buffer {
                result.append(buffer)
            }
@@ -66,7 +66,7 @@ extension SMB2 {
        }
    }
    
-    struct TreeConnectResponse: SMBResponse {
+    struct TreeConnectResponse: SMBResponseBody {
        let size: UInt16  // = 16
        fileprivate let _type: UInt8
        var type: ShareType {
@@ -77,13 +77,6 @@ extension SMB2 {
        let capabilities: TreeConnectResponse.Capabilities
        let maximalAccess: FileAccessMask
        
-        init? (data: Data) {
-            if data.count != 16 {
-                return nil
-            }
-            self = decode(data)
-        }
-        
        enum ShareType: UInt8 {
            case UNKNOWN  = 0x00
            case DISK     = 0x01
@@ -131,7 +124,7 @@ extension SMB2 {
    
    // MARK: SMB2 Tree Disconnect
    
-    struct TreeDisconnect: SMBRequest, SMBResponse {
+    struct TreeDisconnect: SMBRequestBody, SMBResponseBody {
        let size: UInt16
        let reserved: UInt16
        
@@ -139,13 +132,5 @@ extension SMB2 {
            self.size = 4
            self.reserved = 0
        }
-        
-        init? (data: Data) {
-            self = decode(data)
-        }
-        
-        func data() -> Data {
-            return encode(self)
-        }
    }
 }
@@ -8,22 +8,33 @@

 import Foundation

-internal func encode<T>(_ value: inout T) -> Data {
-    return withUnsafePointer(to: &value) { p in
-        Data(bytes: p, count: MemoryLayout.size(ofValue: value))
+extension Data {
+    init<T>(value: T) {
+        var value = value
+        self = Data(buffer: UnsafeBufferPointer(start: &value, count: 1))
    }
-}
-
-internal func encode<T>(_ value: T) -> Data {
-    var value = value
-    return encode(&value)
-}
-
-internal func decode<T>(_ data: Data) -> T {
-    let pointer = UnsafeMutablePointer<T>.allocate(capacity: MemoryLayout<T.Type>.size)
-    (data as NSData).getBytes(pointer, length: MemoryLayout<T.Type>.size)
    
-    return pointer.move()
+    func scanValue<T>() -> T? {
+        guard MemoryLayout<T>.size <= self.count else { return nil }
+        return self.withUnsafeBytes { $0.pointee }
+    }
+    
+    func scanValue<T>(start: Int) -> T? {
+        let length = MemoryLayout<T>.size
+        guard self.count >= start + length else { return nil }
+        return self.subdata(in: start..<start+length).withUnsafeBytes { $0.pointee }
+    }
+    
+    func scanString(start: Int = 0, length: Int, encoding: String.Encoding) -> String? {
+        guard self.count >= start + length else { return nil }
+        return String(data: self.subdata(in: start..<start+length), encoding: encoding)
+    }
+    
+    static func mapMemory<T, U>(from: T) -> U? {
+        guard MemoryLayout<T>.size >= MemoryLayout<U>.size else { return nil }
+        let data = Data(value: from)
+        return data.scanValue()
+    }
 }

 protocol FileProviderSMBHeader {
@@ -10,7 +10,7 @@ import Foundation

 /// Error Types and Description

-public enum NTStatus: UInt32, Error, CustomStringConvertible {
+enum NTStatus: UInt32, Error, CustomStringConvertible {
    case SUCCESS                        = 0x00000000
    case NOT_IMPLEMENTED                = 0xC0000002
    case INVALID_DEVICE_REQUEST         = 0xC0000010
@@ -9,47 +9,64 @@
 import Foundation

 public final class WebDavFileObject: FileObject {
-    public let contentType: String
-    public let entryTag: String?
-    
-    // codebeat:disable[ARITY]
-    public init(absoluteURL: URL, name: String, path: String, size: Int64 = -1, contentType: String = "", createdDate: Date? = nil, modifiedDate: Date? = nil, fileType: FileType = .regular, isHidden: Bool = false, isReadOnly: Bool = false, entryTag: String? = nil) {
-        self.contentType = contentType
-        self.entryTag = entryTag
-        super.init(absoluteURL: absoluteURL, name: name, path: path, size: size, createdDate: createdDate, modifiedDate: modifiedDate, fileType: fileType, isHidden: isHidden, isReadOnly: isReadOnly)
+    internal init(absoluteURL: URL, name: String, path: String) {
+        super.init(absoluteURL: absoluteURL, name: name, path: path)
+    }
+    
+    open internal(set) var contentType: String {
+        get {
+            return allValues["NSURLContentTypeKey"] as? String ?? ""
+        }
+        set {
+            allValues["NSURLContentTypeKey"] = newValue
+        }
+    }
+    
+    open internal(set) var entryTag: String? {
+        get {
+            return allValues["NSURLEntryTagKey"] as? String
+        }
+        set {
+            allValues["NSURLEntryTagKey"] = newValue
+        }
    }
-    // codebeat:enable[ARITY]
 }

-// Because this class uses NSURLSession, it's necessary to disable App Transport Security
-// in case of using this class with unencrypted HTTP connection.
+/// Because this class uses NSURLSession, it's necessary to disable App Transport Security
+/// in case of using this class with unencrypted HTTP connection.

-open class WebDAVFileProvider: NSObject,  FileProviderBasic {
+open class WebDAVFileProvider: NSObject,  FileProviderBasicRemote {
    open static let type: String = "WebDAV"
    open let isPathRelative: Bool = true
    open let baseURL: URL?
    open var currentPath: String = ""
-    open var dispatch_queue: DispatchQueue {
+    public var dispatch_queue: DispatchQueue {
        willSet {
            assert(_session == nil, "It's not effective to change dispatch_queue property after session is initialized.")
        }
    }
-    open weak var delegate: FileProviderDelegate?
+    public weak var delegate: FileProviderDelegate?
    open let credential: URLCredential?
+    open private(set) var cache: URLCache?
+    public var useCache: Bool = false
+    public var validatingCache: Bool = true
    
    fileprivate var _session: URLSession?
    fileprivate var sessionDelegate: SessionDelegate?
-    fileprivate var session: URLSession {
+    public var session: URLSession {
        if _session == nil {
            self.sessionDelegate = SessionDelegate(fileProvider: self, credential: credential)
            let queue = OperationQueue()
            //queue.underlyingQueue = dispatch_queue
-            _session = URLSession(configuration: URLSessionConfiguration.default, delegate: sessionDelegate as URLSessionDownloadDelegate?, delegateQueue: queue)
+            let config = URLSessionConfiguration.default
+            config.urlCache = cache
+            config.requestCachePolicy = .returnCacheDataElseLoad
+            _session = URLSession(configuration: config, delegate: sessionDelegate as URLSessionDownloadDelegate?, delegateQueue: queue)
        }
        return _session!
    }
    
-    public init? (baseURL: URL, credential: URLCredential?) {
+    public init? (baseURL: URL, credential: URLCredential?, cache: URLCache? = nil) {
        if  !["http", "https"].contains(baseURL.uw_scheme.lowercased()) {
            return nil
        }
@@ -57,6 +74,7 @@ open class WebDAVFileProvider: NSObject,  FileProviderBasic {
        dispatch_queue = DispatchQueue(label: "FileProvider.\(WebDAVFileProvider.type)", attributes: DispatchQueue.Attributes.concurrent)
        //let url = baseURL.uw_absoluteString
        self.credential = credential
+        self.cache = cache
    }
    
    deinit {
@@ -64,6 +82,7 @@ open class WebDAVFileProvider: NSObject,  FileProviderBasic {
    }
    
    open func contentsOfDirectory(path: String, completionHandler: @escaping ((_ contents: [FileObject], _ error: Error?) -> Void)) {
+        let opType = FileOperationType.fetch(path: path)
        let url = absoluteURL(path)
        var request = URLRequest(url: url)
        request.httpMethod = "PROPFIND"
@@ -71,7 +90,7 @@ open class WebDAVFileProvider: NSObject,  FileProviderBasic {
        request.setValue("text/xml; charset=\"utf-8\"", forHTTPHeaderField: "Content-Type")
        request.httpBody = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<D:propfind xmlns:D=\"DAV:\">\n<D:allprop/></D:propfind>".data(using: .utf8)
        request.setValue(String(request.httpBody!.count), forHTTPHeaderField: "Content-Length")
-        let task = session.dataTask(with: request, completionHandler: { (data, response, error) in
+        runDataTask(with: request, operationHandle: RemoteOperationHandle(operationType: opType, tasks: []), completionHandler: { (data, response, error) in
            var responseError: FileProviderWebDavError?
            if let code = (response as? HTTPURLResponse)?.statusCode , code >= 300, let rCode = FileProviderHTTPErrorCode(rawValue: code) {
                responseError = FileProviderWebDavError(code: rCode, url: url)
@@ -87,8 +106,7 @@ open class WebDAVFileProvider: NSObject,  FileProviderBasic {
                }
            }
            completionHandler(fileObjects, responseError ?? error)
-        }) 
-        task.resume()
+        })
    }
    
    open func attributesOfItem(path: String, completionHandler: @escaping ((_ attributes: FileObject?, _ error: Error?) -> Void)) {
@@ -99,7 +117,7 @@ open class WebDAVFileProvider: NSObject,  FileProviderBasic {
        request.setValue("text/xml; charset=\"utf-8\"", forHTTPHeaderField: "Content-Type")
        request.httpBody = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<D:propfind xmlns:D=\"DAV:\">\n<D:allprop/></D:propfind>".data(using: .utf8)
        request.setValue(String(request.httpBody!.count), forHTTPHeaderField: "Content-Length")
-        let task = session.dataTask(with: request, completionHandler: { (data, response, error) in
+        runDataTask(with: request, completionHandler: { (data, response, error) in
            var responseError: FileProviderWebDavError?
            if let code = (response as? HTTPURLResponse)?.statusCode, code >= 300, let rCode = FileProviderHTTPErrorCode(rawValue: code) {
                responseError = FileProviderWebDavError(code: rCode, url: url)
@@ -113,7 +131,6 @@ open class WebDAVFileProvider: NSObject,  FileProviderBasic {
            }
            completionHandler(nil, responseError ?? error)
        })
-        task.resume()
    }
    
    open func storageProperties(completionHandler: @escaping ((_ total: Int64, _ used: Int64) -> Void)) {
@@ -129,7 +146,7 @@ open class WebDAVFileProvider: NSObject,  FileProviderBasic {
        request.setValue("text/xml; charset=\"utf-8\"", forHTTPHeaderField: "Content-Type")
        request.httpBody = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<D:propfind xmlns:D=\"DAV:\">\n<D:prop><D:quota-available-bytes/><D:quota-used-bytes/></D:prop>\n</D:propfind>".data(using: .utf8)
        request.setValue(String(request.httpBody!.count), forHTTPHeaderField: "Content-Length")
-        let task = session.dataTask(with: request, completionHandler: { (data, response, error) in
+        runDataTask(with: request, completionHandler: { (data, response, error) in
            var totalSize: Int64 = -1
            var usedSize: Int64 = 0
            if let data = data {
@@ -140,8 +157,7 @@ open class WebDAVFileProvider: NSObject,  FileProviderBasic {
                }
            }
            completionHandler(totalSize, usedSize)
-        }) 
-        task.resume()
+        })
    }
    
    open weak var fileOperationDelegate: FileOperationDelegate?
@@ -150,7 +166,8 @@ open class WebDAVFileProvider: NSObject,  FileProviderBasic {
 extension WebDAVFileProvider: FileProviderOperations {
    @discardableResult
    public func create(folder folderName: String, at atPath: String, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
-        guard fileOperationDelegate?.fileProvider(self, shouldDoOperation: .create(path: (atPath as NSString).appendingPathComponent(folderName) + "/")) ?? true == true else {
+        let opType = FileOperationType.create(path: (atPath as NSString).appendingPathComponent(folderName) + "/")
+        guard fileOperationDelegate?.fileProvider(self, shouldDoOperation: opType) ?? true == true else {
            return nil
        }
        let url = absoluteURL((atPath as NSString).appendingPathComponent(folderName) + "/")
@@ -162,18 +179,20 @@ extension WebDAVFileProvider: FileProviderOperations {
                responseError = FileProviderWebDavError(code: rCode, url: url)
            }
            completionHandler?(responseError ?? error)
-            self.delegateNotify(.create(path: (atPath as NSString).appendingPathComponent(folderName) + "/"), error: responseError ?? error)
+            self.delegateNotify(opType, error: responseError ?? error)
        })
+        task.taskDescription = opType.json
        task.resume()
-        return RemoteOperationHandle(tasks: [task])
+        return RemoteOperationHandle(operationType: opType, tasks: [task])
    }
    
    @discardableResult
-    public func create(file fileAttribs: FileObject, at path: String, contents data: Data?, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
-        guard fileOperationDelegate?.fileProvider(self, shouldDoOperation: .create(path: path)) ?? true == true else {
+    public func create(file fileName: String, at path: String, contents data: Data?, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
+        let opType = FileOperationType.create(path: (path as NSString).appendingPathComponent(fileName))
+        guard fileOperationDelegate?.fileProvider(self, shouldDoOperation: opType) ?? true == true else {
            return nil
        }
-        let url = absoluteURL(path)
+        let url = absoluteURL(path).appendingPathComponent(fileName)
        var request = URLRequest(url: url)
        request.httpMethod = "PUT"
        let task = session.uploadTask(with: request, from: data, completionHandler: { (data, response, error) in
@@ -182,97 +201,88 @@ extension WebDAVFileProvider: FileProviderOperations {
                responseError = FileProviderWebDavError(code: rCode, url: url)
            }
            completionHandler?(responseError ?? error)
-            self.delegateNotify(.create(path: (path as NSString).appendingPathComponent(fileAttribs.name)), error: responseError ?? error)
+            self.delegateNotify(opType, error: responseError ?? error)
        })
-        task.taskDescription = dictionaryToJSON(["type": "Create" as NSString, "source": (path as NSString).appendingPathComponent(fileAttribs.name) as NSString])
+        task.taskDescription = opType.json
        task.resume()
-        return RemoteOperationHandle(tasks: [task])
+        return RemoteOperationHandle(operationType: opType, tasks: [task])
    }
    
    @discardableResult
    public func moveItem(path: String, to toPath: String, overwrite: Bool = false, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
-        guard fileOperationDelegate?.fileProvider(self, shouldDoOperation: .move(source: path, destination: toPath)) ?? true == true else {
+        let opType = FileOperationType.move(source: path, destination: toPath)
+        guard fileOperationDelegate?.fileProvider(self, shouldDoOperation: opType) ?? true == true else {
            return nil
        }
-        return self.copyMoveItem(move: true, path: path, toPath: toPath, overwrite: overwrite, completionHandler: completionHandler)
+        return self.doOperation(operation: opType, overwrite: overwrite, completionHandler: completionHandler)
    }
    
    @discardableResult
    public func copyItem(path: String, to toPath: String, overwrite: Bool = false, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
-        guard fileOperationDelegate?.fileProvider(self, shouldDoOperation: .copy(source: path, destination: toPath)) ?? true == true else {
+        let opType = FileOperationType.copy(source: path, destination: toPath)
+        guard fileOperationDelegate?.fileProvider(self, shouldDoOperation: opType) ?? true == true else {
            return nil
        }
-        return self.copyMoveItem(move: false, path: path, toPath: toPath, overwrite: overwrite, completionHandler: completionHandler)
+        return self.doOperation(operation: opType, overwrite: overwrite, completionHandler: completionHandler)
    }
    
-    fileprivate func copyMoveItem(move:Bool, path: String, toPath: String, overwrite: Bool, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
-        let url = absoluteURL(path)
-        var request = URLRequest(url: url)
-        if move {
-            request.httpMethod = "MOVE"
-        } else {
-            request.httpMethod = "COPY"
+    @discardableResult
+    public func removeItem(path: String, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
+        let opType = FileOperationType.remove(path: path)
+        guard fileOperationDelegate?.fileProvider(self, shouldDoOperation: opType) ?? true == true else {
+            return nil
        }
-        request.setValue(absoluteURL(path).absoluteString, forHTTPHeaderField: "Destination")
-        if !overwrite {
+        return self.doOperation(operation: opType, completionHandler: completionHandler)
+    }
+    
+    func doOperation(operation opType: FileOperationType, overwrite: Bool? = nil, completionHandler: SimpleCompletionHandler) -> OperationHandle?  {
+        let sourceURL = absoluteURL(opType.source!)
+        var request = URLRequest(url: sourceURL)
+        if let dest = opType.destination {
+            request.setValue(absoluteURL(dest).absoluteString, forHTTPHeaderField: "Destination")
+        }
+        switch opType {
+        case .copy:
+            request.httpMethod = "COPY"
+        case .move:
+            request.httpMethod = "MOVE"
+        case .remove:
+            request.httpMethod = "DELETE"
+        default:
+            return nil
+        }
+        
+        if let overwrite = overwrite, !overwrite {
            request.setValue("F", forHTTPHeaderField: "Overwrite")
        }
        let task = session.dataTask(with: request, completionHandler: { (data, response, error) in
            var responseError: FileProviderWebDavError?
            if let response = response as? HTTPURLResponse, let code = FileProviderHTTPErrorCode(rawValue: response.statusCode) {
                if response.statusCode >= 300  {
-                    responseError = FileProviderWebDavError(code: code, url: url)
+                    responseError = FileProviderWebDavError(code: code, url: sourceURL)
                }
                if code == .multiStatus, let data = data {
                    let xresponses = self.parseXMLResponse(data)
                    for xresponse in xresponses where (xresponse.status ?? 0) >= 300 {
-                        completionHandler?(FileProviderWebDavError(code: code, url: url))
+                        completionHandler?(FileProviderWebDavError(code: code, url: sourceURL))
                    }
                }
            }
            if (response as? HTTPURLResponse)?.statusCode ?? 0 != FileProviderHTTPErrorCode.multiStatus.rawValue {
                completionHandler?(responseError ?? error)
            }
-            let op = move ? FileOperationType.move(source: path, destination: toPath) : .copy(source: path, destination: toPath)
-            self.delegateNotify(op, error: responseError ?? error)
+            
+            self.delegateNotify(opType, error: responseError ?? error)
        })
+        task.taskDescription = opType.json
        task.resume()
-        return RemoteOperationHandle(tasks: [task])
-    }
-    
-    @discardableResult
-    public func removeItem(path: String, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
-        guard fileOperationDelegate?.fileProvider(self, shouldDoOperation: .remove(path: path)) ?? true == true else {
-            return nil
-        }
-        let url = absoluteURL(path)
-        var request = URLRequest(url: url)
-        request.httpMethod = "DELETE"
-        let task = session.dataTask(with: request, completionHandler: { (data, response, error) in
-            var responseError: FileProviderWebDavError?
-            if let response = response as? HTTPURLResponse, let code = FileProviderHTTPErrorCode(rawValue: response.statusCode) {
-                if response.statusCode >= 300  {
-                    responseError = FileProviderWebDavError(code: code, url: url)
-                }
-                if code == .multiStatus, let data = data {
-                    let xresponses = self.parseXMLResponse(data)
-                    for xresponse in xresponses where (xresponse.status ?? 0) >= 300 {
-                        completionHandler?(FileProviderWebDavError(code: code, url: url))
-                    }
-                }
-            }
-            if (response as? HTTPURLResponse)?.statusCode ?? 0 != FileProviderHTTPErrorCode.multiStatus.rawValue {
-                completionHandler?(responseError ?? error)
-            }
-            self.delegateNotify(.remove(path: path), error: responseError ?? error)
-        })
-        task.resume()
-        return RemoteOperationHandle(tasks: [task])
+        return RemoteOperationHandle(operationType: opType, tasks: [task])
    }
    
    @discardableResult
    public func copyItem(localFile: URL, to toPath: String, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
-        guard fileOperationDelegate?.fileProvider(self, shouldDoOperation: .copy(source: localFile.absoluteString, destination: toPath)) ?? true == true else {
+        let opType = FileOperationType.copy(source: localFile.absoluteString, destination: toPath)
+        guard fileOperationDelegate?.fileProvider(self, shouldDoOperation: opType) ?? true == true else {
            return nil
        }
        let url = absoluteURL(toPath)
@@ -284,16 +294,17 @@ extension WebDAVFileProvider: FileProviderOperations {
                responseError = FileProviderWebDavError(code: rCode, url: url)
            }
            completionHandler?(responseError ?? error)
-            self.delegateNotify(.copy(source: localFile.absoluteString, destination: toPath), error: responseError ?? error)
+            self.delegateNotify(opType, error: responseError ?? error)
        }) 
-        task.taskDescription = dictionaryToJSON(["type": "Copy" as NSString, "source": localFile.absoluteString as NSString, "dest": toPath as NSString])
+        task.taskDescription = opType.json
        task.resume()
-        return RemoteOperationHandle(tasks: [task])
+        return RemoteOperationHandle(operationType: opType, tasks: [task])
    }
    
    @discardableResult
    public func copyItem(path: String, toLocalURL: URL, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
-        guard fileOperationDelegate?.fileProvider(self, shouldDoOperation: .copy(source: path, destination: toLocalURL.absoluteString)) ?? true == true else {
+        let opType = FileOperationType.copy(source: path, destination: toLocalURL.absoluteString)
+        guard fileOperationDelegate?.fileProvider(self, shouldDoOperation: opType) ?? true == true else {
            return nil
        }
        let url = absoluteURL(path)
@@ -312,11 +323,11 @@ extension WebDAVFileProvider: FileProviderOperations {
                }
            }
            completionHandler?(responseError ?? error)
-            self.delegateNotify(.copy(source: path, destination: toLocalURL.absoluteString), error: responseError ?? error)
+            self.delegateNotify(opType, error: responseError ?? error)
        }) 
-        task.taskDescription = dictionaryToJSON(["type": "Copy" as NSString, "source": path as NSString, "dest": toLocalURL.absoluteString as NSString])
+        task.taskDescription = opType.json
        task.resume()
-        return RemoteOperationHandle(tasks: [task])
+        return RemoteOperationHandle(operationType: opType, tasks: [task])
    }
 }

@@ -328,6 +339,7 @@ extension WebDAVFileProvider: FileProviderReadWrite {
    
    @discardableResult
    public func contents(path: String, offset: Int64, length: Int, completionHandler: @escaping ((_ contents: Data?, _ error: Error?) -> Void)) -> OperationHandle? {
+        let opType = FileOperationType.fetch(path: path)
        let url = absoluteURL(path)
        var request = URLRequest(url: url)
        request.httpMethod = "GET"
@@ -336,20 +348,21 @@ extension WebDAVFileProvider: FileProviderReadWrite {
        } else if offset > 0 && length < 0 {
            request.setValue("bytes=\(offset)-", forHTTPHeaderField: "Range")
        }
-        let task = session.dataTask(with: request, completionHandler: { (data, response, error) in
+        let handle = RemoteOperationHandle(operationType: opType, tasks: [])
+        runDataTask(with: request, operationHandle: handle, completionHandler: { (data, response, error) in
            var responseError: FileProviderWebDavError?
            if let code = (response as? HTTPURLResponse)?.statusCode , code >= 300, let rCode = FileProviderHTTPErrorCode(rawValue: code) {
                responseError = FileProviderWebDavError(code: rCode, url: url)
            }
            completionHandler(data, responseError ?? error)
-        }) 
-        task.resume()
-        return RemoteOperationHandle(tasks: [task])
+        })
+        return handle
    }
    
    @discardableResult
    public func writeContents(path: String, contents data: Data, atomically: Bool = false, completionHandler: SimpleCompletionHandler) -> OperationHandle? {
-        guard fileOperationDelegate?.fileProvider(self, shouldDoOperation: .modify(path: path)) ?? true == true else {
+        let opType = FileOperationType.modify(path: path)
+        guard fileOperationDelegate?.fileProvider(self, shouldDoOperation: opType) ?? true == true else {
            return nil
        }
        // FIXME: lock destination before writing process
@@ -362,7 +375,7 @@ extension WebDAVFileProvider: FileProviderReadWrite {
                responseError = FileProviderWebDavError(code: rCode, url: self.absoluteURL(path))
            }
            defer {
-                self.delegateNotify(.modify(path: path), error: responseError ?? error)
+                self.delegateNotify(opType, error: responseError ?? error)
            }
            if let error = error {
                completionHandler?(error)
@@ -372,9 +385,9 @@ extension WebDAVFileProvider: FileProviderReadWrite {
                self.moveItem(path: (path as NSString).appendingPathExtension("tmp")!, to: path, completionHandler: completionHandler)
            }
        }) 
-        task.taskDescription = dictionaryToJSON(["type": "Modify" as NSString, "source": path as NSString])
+        task.taskDescription = opType.json
        task.resume()
-        return RemoteOperationHandle(tasks: [task])
+        return RemoteOperationHandle(operationType: opType, tasks: [task])
    }
    
    public func searchFiles(path: String, recursive: Bool, query: String, foundItemHandler: ((FileObject) -> Void)?, completionHandler: @escaping ((_ files: [FileObject], _ error: Error?) -> Void)) {
@@ -384,8 +397,7 @@ extension WebDAVFileProvider: FileProviderReadWrite {
        //request.setValue("1", forHTTPHeaderField: "Depth")
        request.setValue("text/xml; charset=\"utf-8\"", forHTTPHeaderField: "Content-Type")
        request.httpBody = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n<D:propfind xmlns:D=\"DAV:\">\n<D:allprop/></D:propfind>".data(using: .utf8)
-        request.setValue(String(request.httpBody!.count), forHTTPHeaderField: "Content-Length")
-        let task = session.dataTask(with: request, completionHandler: { (data, response, error) in
+        runDataTask(with: request, completionHandler: { (data, response, error) in
            // FIXME: paginating results
            var responseError: FileProviderWebDavError?
            if let code = (response as? HTTPURLResponse)?.statusCode , code >= 300, let rCode = FileProviderHTTPErrorCode(rawValue: code) {
@@ -407,8 +419,7 @@ extension WebDAVFileProvider: FileProviderReadWrite {
                return
            }
            completionHandler([], responseError ?? error)
-        }) 
-        task.resume()
+        })
    }
    
    fileprivate func registerNotifcation(path: String, eventHandler: (() -> Void)) {
@@ -425,7 +436,17 @@ extension WebDAVFileProvider: FileProviderReadWrite {
    // TODO: implements methods for lock mechanism
 }

-extension WebDAVFileProvider: FileProvider {}
+extension WebDAVFileProvider: FileProvider {
+    open func copy(with zone: NSZone? = nil) -> Any {
+        let copy = WebDAVFileProvider(baseURL: self.baseURL!, credential: self.credential, cache: self.cache)!
+        copy.currentPath = self.currentPath
+        copy.delegate = self.delegate
+        copy.fileOperationDelegate = self.fileOperationDelegate
+        copy.useCache = self.useCache
+        copy.validatingCache = self.validatingCache
+        return copy
+    }
+}

 // MARK: WEBDAV XML response implementation

@@ -514,13 +535,14 @@ internal extension WebDAVFileProvider {
            href = absoluteURL(href.path)
        }
        let name = davResponse.prop["displayname"] ?? (davResponse.hrefString.removingPercentEncoding! as NSString).lastPathComponent
-        let size = Int64(davResponse.prop["getcontentlength"] ?? "-1") ?? NSURLSessionTransferSizeUnknown
-        let createdDate = self.resolve(dateString: davResponse.prop["creationdate"] ?? "")
-        let modifiedDate = self.resolve(dateString: davResponse.prop["getlastmodified"] ?? "")
-        let contentType = davResponse.prop["getcontenttype"] ?? "octet/stream"
-        let isDirectory = contentType == "httpd/unix-directory"
-        let entryTag = davResponse.prop["getetag"]
-        return WebDavFileObject(absoluteURL: href, name: name, path: href.path, size: size, contentType: contentType, createdDate: createdDate, modifiedDate: modifiedDate, fileType: isDirectory ? .directory : .regular, isHidden: false, isReadOnly: false, entryTag: entryTag)
+        let fileObject = WebDavFileObject(absoluteURL: href, name: name, path: href.path)
+        fileObject.size = Int64(davResponse.prop["getcontentlength"] ?? "-1") ?? NSURLSessionTransferSizeUnknown
+        fileObject.creationDate = self.resolve(dateString: davResponse.prop["creationdate"] ?? "")
+        fileObject.modifiedDate = self.resolve(dateString: davResponse.prop["getlastmodified"] ?? "")
+        fileObject.contentType = davResponse.prop["getcontenttype"] ?? "octet/stream"
+        fileObject.fileType = fileObject.contentType == "httpd/unix-directory" ? .directory : .regular
+        fileObject.entryTag = davResponse.prop["getetag"]
+        return fileObject
    }
    
    fileprivate func delegateNotify(_ operation: FileOperationType, error: Error?) {
Author	SHA1	Message	Date
Amir Abbas	8bad5944bc	Updated pod spec version to 0.8.1	2016-12-07 02:36:49 +03:30
Amir Abbas	6ef2ab11c4	Fixed bug in Data(value:) initializer. Switch uuid init via this	2016-12-07 02:34:34 +03:30
Amir Abbas Mousavian	7f27d46c70	Merge pull request #16 from RndmTsk/master Fixes #15, FileObject.fileType always returns nil.	2016-12-07 02:29:28 +03:30
Terry Latanville	b1ec99b1b8	Fixes #15 , FileObject.fileType always returns nil.	2016-12-06 17:18:41 -05:00
Amir Abbas Mousavian	c4b8065cd3	Merge pull request #14 from skela/master Update DropboxFileProvider.swift	2016-12-06 10:51:58 +03:30
Alek Slater	2d8454c711	Update DropboxFileProvider.swift Using the same request dict creation method that can be found in the contents method, to avoid error when trying to use copyItem to copy a remote file to a local file destination.	2016-12-06 14:51:48 +08:00
Amir Abbas Mousavian	3b35c066de	fixed get_temporary_link url	2016-12-03 20:40:04 +03:30
Amir Abbas Mousavian	7d8de9cefe	FileObject init accessors fixed, refactoring	2016-12-03 20:26:27 +03:30
Amir Abbas Mousavian	e84fef20ea	[gardening] Refactoring WebDAV copy, move and remove operations	2016-12-03 15:32:54 +03:30
Amir Abbas Mousavian	4a9a3196a2	Dropbox `get_temporary_link` and `save_url` implementations	2016-12-03 15:12:11 +03:30
Amir Abbas Mousavian	f4e6d277ae	Updated source highlighting	2016-12-03 13:34:32 +03:30
Amir Abbas Mousavian	1328a8e9e2	New FIleObject implementation, highlighted Readme	2016-12-03 13:21:13 +03:30
Amir Abbas Mousavian	5bf620916f	Fixes #12 , createFile method path in WebDAV is not correct. - removed NSURL cast for resource values, now using swift 3 methods	2016-12-02 01:12:08 +03:30
Amir Abbas Mousavian	4f56e20441	createFile definition improved to resolve #10	2016-12-01 12:12:53 +03:30
Amir Abbas Mousavian	9dda618b73	Revert "createFile definition improved" This reverts commit `da60c05188`.	2016-12-01 12:10:14 +03:30
Amir Abbas Mousavian	da60c05188	createFile definition improved	2016-12-01 11:54:03 +03:30
Amir Abbas Mousavian	4366855d54	Added NSCopying conformance, SMB headers gardening	2016-11-28 19:40:09 +03:30
Amir Abbas Mousavian	fe05fd83fe	Replaced encode/decode methods with Data extension	2016-11-26 00:11:46 +03:30
Amir Abbas Mousavian	826d207e6b	OperationHandle optimizations - code refactoring for RemoteOperationHandle usage and description - bug fix: move operation in Dropbox provider did copy - bug fix: dynamic inProgress result for RemoteOperationHandle	2016-11-24 22:54:00 +03:30