C# FileSystem.FileHeader类代码示例

        public async Task<FileHeader> LoadFileAsync(string filename)
        {
            if (string.IsNullOrWhiteSpace(filename))
                throw new ArgumentNullException("filename", "The filename cannot be null, empty or whitespace.");

			FileHeader existingEntity;
            if (entitiesByKey.TryGetValue(filename, out existingEntity))
            {
                // Check if the file is not currently been scheduled for deletion or known to be non-existent.
                if (!this.IsDeleted(filename))
                    return existingEntity;
                else
                    return null;
            }

            IncrementRequestCount();            

            // Check if the file exists on the server.
            var metadata = await Commands.GetMetadataForAsync(filename);
            if (metadata == null)
                return null;

            var fileHeader = new FileHeader(filename, metadata);
            AddToCache(filename, fileHeader);

            return fileHeader;
        }

        public UpdateMetadataOperation(InMemoryFilesSessionOperations sessionOperations, FileHeader fileHeader, RavenJObject metadata)
        {
            if (fileHeader != null && string.IsNullOrWhiteSpace(fileHeader.FullPath))
                throw new ArgumentNullException("fileHeader", "The file cannot be null or have an empty or whitespace name.");

            this.sessionOperations = sessionOperations;

            this.FileHeader = fileHeader;
            this.Filename = fileHeader.FullPath;
            this.Metadata = metadata;
        }

        public UpdateMetadataOperation(InMemoryFilesSessionOperations sessionOperations, FileHeader fileHeader, RavenJObject metadata, Etag etag)
        {
            if (fileHeader == null || string.IsNullOrWhiteSpace(fileHeader.FullPath))
                throw new ArgumentNullException("fileHeader", "The file cannot be null or have an empty or whitespace name!");

            this.sessionOperations = sessionOperations;

            FileHeader = fileHeader;
            FileName = fileHeader.FullPath;
            Metadata = metadata;
            Etag = etag;
        }

        public void ConflictNotificationSerialization()
        {
			var metadata = new RavenJObject { { Constants.LastModified, "2014-07-07T12:00:00.0000000" }, { Constants.FileSystem.RavenFsSize, "128" } };
            var fileHeader = new FileHeader("test1.file", metadata);
            var notification = new ConflictNotification() { FileName = "test1.file", SourceServerUrl = "http://destination", RemoteFileHeader = fileHeader, Status = ConflictStatus.Detected};

            var serializedValue = JsonExtensions.ToJObject(notification);

            var jr = new RavenJTokenReader(serializedValue);
            var deserializedValue = JsonExtensions.CreateDefaultJsonSerializer().Deserialize<ConflictNotification>(jr);

            Assert.NotNull(deserializedValue);
        }

        public void FileHeaderSerialization()
        {
			var metadata = new RavenJObject { { Constants.LastModified, "2014-07-07T12:00:00.0000000" }, { Constants.FileSystem.RavenFsSize, "128" } };
            var fileHeader = new FileHeader("test1.file", metadata);

            var serializedValue = JsonExtensions.ToJObject(fileHeader);

            var jr = new RavenJTokenReader(serializedValue);
            var deserializedValue = JsonExtensions.CreateDefaultJsonSerializer().Deserialize<FileHeader>(jr);

            Assert.NotNull(deserializedValue);
            Assert.Equal(fileHeader.Name, deserializedValue.Name);
            Assert.Equal(fileHeader.LastModified, deserializedValue.LastModified);
        }

        public bool Filter(FileHeader file, Guid destinationId, IEnumerable<FileHeader> candidatesToSynchronization)
		{
			// prevent synchronization back to source
			if (file.Metadata.Value<Guid>(SynchronizationConstants.RavenSynchronizationSource) == destinationId)
				return false;

            if (file.FullPath.EndsWith(RavenFileNameHelper.DownloadingFileSuffix))
				return false;

            if (file.FullPath.EndsWith(RavenFileNameHelper.DeletingFileSuffix))
				return false;

			if (file.IsFileBeingUploadedOrUploadHasBeenBroken())
				return false;

            if (ExistsRenameTombstone(file.FullPath, candidatesToSynchronization))
				return false;

			return true;
		}

        public void RegisterFileDeletion(FileHeader file, Etag etag = null)
        {
			deletedEntities.Add(file.Directory);

			var operation = new DeleteFileOperation(this, file.Directory, etag);

            IncrementRequestCount();

            registeredOperations.Enqueue(operation); 
        }

        private FileHeader GetSmallest(FileHeader[][] applyAsync, int[] indexes, int[] originalIndexes)
        {
            FileHeader smallest = null;
            var smallestIndex = -1;
            for (var i = 0; i < applyAsync.Length; i++)
            {

                var pos = indexes[i] - originalIndexes[i];
                if (pos >= applyAsync[i].Length)
                    continue;

                var current = applyAsync[i][pos];
                if (smallest == null ||
                    string.Compare(current.FullPath, smallest.FullPath, StringComparison.OrdinalIgnoreCase) < 0)
                {
                    smallest = current;
                    smallestIndex = i;
                }
            }

            if (smallestIndex != -1)
                indexes[smallestIndex]++;

            return smallest;
        }

        private int CompareFileInfos(FileHeader current, FileHeader smallest, string[] sortFields)
        {
            if (sortFields == null || sortFields.Length == 0)
            {
                return string.Compare(current.FullPath, smallest.FullPath, StringComparison.OrdinalIgnoreCase);
            }
            foreach (var sortField in sortFields)
            {
                var field = sortField;
                var multiplay = 1; //for asending decending
                if (sortField.StartsWith("-"))
                {
                    field = sortField.TrimStart(new[] { '-' });
                    multiplay = -1;
                }

                if (field.Equals("__size", StringComparison.OrdinalIgnoreCase))
                {
                    var currentItem = current.TotalSize;
                    var smallestItem = smallest.TotalSize;

                    if (currentItem == null && smallestItem == null)
                        continue;

                    if (currentItem == null)
                        return 1 * multiplay;

                    if (smallestItem == null)
                        return -1 * multiplay;


                    var compare = (long)(currentItem - smallestItem);
                    if (compare != 0)
                        return Math.Sign(compare) * multiplay;
                }
                else
                {
                    var currentItem = current.Metadata.Value<string>(field);
                    var smallestItem = smallest.Metadata.Value<string>(field);
                    
                    var compare = string.Compare(currentItem, smallestItem, StringComparison.OrdinalIgnoreCase);
                    if (compare != 0)
                        return compare * multiplay;
                }
            }

            return 0;
        }

        internal bool TryGetFromCache(string filename, out FileHeader fileHeader)
        {
            fileHeader = null;

            if (entitiesByKey.ContainsKey(filename))
                fileHeader = entitiesByKey[filename];

            return fileHeader != null;
        }

        public bool EntityChanged(FileHeader fileHeader)
        {
            if (fileHeader == null)
                return true;

            return RavenJToken.DeepEquals(fileHeader.Metadata, fileHeader.OriginalMetadata, null) == false;
        }

 public void RegisterRename(FileHeader sourceFile, string destinationFile, Etag etag = null)
 {
     RegisterRename(sourceFile.FullPath, destinationFile, etag);
 }

        public void AddToCache(string filename, FileHeader fileHeader)
        {
            if (!entitiesByKey.ContainsKey(filename))
                entitiesByKey.Add(filename, fileHeader);
            else
                entitiesByKey[filename] = fileHeader;

            if (this.IsDeleted(filename))
                knownMissingIds.Remove(filename);
        }

 public void ConflictResolved(FileHeader header)
 {
     ResolvedCount++;
 }

        public void RegisterFileDeletion(FileHeader file, Etag etag = null)
        {
			RegisterFileDeletion(file.FullPath, etag);
        }