public async Task<Hash> PutAsync(long id, SemanticVersion version, IPackage package)
        {
            #region Preconditions

            if (package == null) throw new ArgumentNullException(nameof(package));

            #endregion

            var key = id.ToString() + "/" + version.ToString();

            using (var ms = new MemoryStream())
            {
                await package.ZipToStreamAsync(ms).ConfigureAwait(false);

                var hash = Hash.ComputeSHA256(ms, leaveOpen: true);

                var blob = new Blob(ms) {
                    ContentType = "application/zip"
                };

                await bucket.PutAsync(key, blob).ConfigureAwait(false);

                return hash;
            }
        }

 /// <summary>
 /// Create an EncryptedContent where all the values are unspecified.
 /// </summary>
 ///
 public EncryptedContent()
 {
     this.algorithmType_ = net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.NONE;
     this.keyLocator_ = new KeyLocator();
     this.initialVector_ = new Blob();
     this.payload_ = new Blob();
 }

    public bool[][] ComputeGrid(Blob[] blobs)
    {
        int sizeX = (int)(_gridBound.rect.width / GridStep) + 1;
        int sizeY = (int)(_gridBound.rect.height / GridStep) + 1;

        var grid = new bool[sizeY][];
        for (int i = 0; i < sizeY; i++)
            grid[i] = new bool[sizeX];

        for (int i = 0; i < sizeY; i++)
            for (int j = 0; j < sizeX; j++)
            {
                float y = _gridBound.offsetMin.y + i * GridStep;
                float x = _gridBound.offsetMin.x + j * GridStep;
                var pos = new Vector2(x, y);

                float totalWeigth = 0;
                foreach (Blob blob in blobs)
                {
                    float distance = Vector2.Distance(pos, blob.transform.position);

                    float weight = blob.WeightFunction(distance);
                    if (weight < 0)
                        weight = 0;

                    totalWeigth += weight;
                }

                grid[i][j] = totalWeigth > WeightThreshold;
            }

        return grid;
    }

        public static void testData() { 
            byte[] origData = new byte[1024];
			for (int i = 0; i < origData.Length; i++) {
				origData[i] = (byte)i;
			}
			
			{
				
                Blob blob = new Blob(origData, "application/octet-stream");
				Debug.Assert(origData.Length == blob.getSize());

				for (int i = 0; i < origData.Length; i++) {
					Debug.Assert(origData[i] == blob.getData()[i]);
				}
			}
			
			Data data = new Data(origData, "application/octet-stream");
			Blob blob2 = data.getBinary();
			
			byte[] newData = blob2.getData();
			
			if (newData.Length == origData.Length);
			for (int i = 0; i < origData.Length; i++) {
                Debug.Assert(newData[i] == origData[i]);
			}

        }

 public VenueMapNotFoundViewModel(Blob blob, FourOhFourReason reason)
 {
     Reason = reason;
     Blob = blob;
     Month = string.Empty;
     Year = DateTime.Now.Year.ToString();
 }

        public IStorableObject ToGitObject(Repository repo, string sha)
        {
            using (GitObjectReader objectReader = new GitObjectReader(Content))
              {
            IStorableObject obj;
            switch (Type)
            {
              case ObjectType.Commit:
              obj = new Commit(repo, sha);
              break;
            case ObjectType.Tree:
              obj = new Tree(repo, sha);
              break;
            case ObjectType.Blob:
              obj = new Blob(repo, sha);
              break;
            case ObjectType.Tag:
              obj = new Tag(repo, sha);
              break;
            default:
              throw new NotImplementedException();
            }

            obj.Deserialize(objectReader);
            return obj;
              }
        }

 public HashSet<string> GetWithPrefix(string prefix, int maxSize)
 {
     Blob<HashSet<KeyValuePair<string, string>>> rootBlob = new Blob<HashSet<KeyValuePair<string, string>>>(dir.GetBlobReference("root"));
     HashSet<KeyValuePair<string, string>> set = rootBlob.Get();
     set.RemoveWhere((p) => p.Key.StartsWith(prefix));
     return new HashSet<string>(set.Select((p) => p.Value));
 }

        //List all files in a specific folder(for example, folder name:  a/b/c). return the list of blob info.
        public List<Blob> ListFilesInSpecificFolder(string container, string folderName)
        {
            BlobStorage blobStorage = new BlobStorage(container);
            //Add prefix before listing all files
            string blobPrefix = folderName + "/";
            if (string.IsNullOrEmpty(folderName) || string.IsNullOrWhiteSpace(folderName))
            {
                blobPrefix = null;
            }
            //Not to list the files in subfolder
            bool useFlatBlobListing = false;
            var blobs = blobStorage.Container.ListBlobs(blobPrefix, useFlatBlobListing, BlobListingDetails.None);
            //To get all files
            var files = blobs.Where(b => b as CloudBlobDirectory == null).ToList();

            var list = new List<Blob>();
            foreach (var file in files)
            {
                var blob = new Blob();
                //To get blob info
                blob.Name = Path.GetFileName(file.Uri.ToString());
                blob.Uri = file.Uri.ToString();
                list.Add(blob);
            }
            return list;
        }

 //List all foders in the root of the container
 public List<Blob> ListFoldersInRootOfContainer(string container)
 {
     BlobStorage blobStorage = new BlobStorage(container);
     string blobPrefix = null;
     //Not to list the files in subfolder
     bool useFlatBlobListing = false;
     var blobs = blobStorage.Container.ListBlobs(blobPrefix, useFlatBlobListing, BlobListingDetails.None);
     //To get all the directory
     var folders = blobs.Where(b => b as CloudBlobDirectory != null).ToList();
     var list = new List<Blob>();
     string folderName;
     foreach (var folder in folders)
     {
         var blob = new Blob();
         //Get the folder name
         folderName = folder.Uri.ToString();
         folderName = folderName.Substring(0, folderName.Length - 1);
         folderName = folderName.Substring(folderName.LastIndexOf("/") + 1);
         //Assign the folder name and Uri
         blob.Name = folderName;
         blob.Uri = folder.Uri.ToString();
         list.Add(blob);
     }
     //Return the list
     return list;
 }

 internal BlobStream(ConnectPackageCreationParameters connectPackageParameters, Blob blob)
 {
     _connectPackageParameters = connectPackageParameters;
     _blob = blob;
     _length = blob.ContentLength;
     _canWrite = true;
 }

        public void AttachBlobs()
        {
            Blob blob = new Blob(IOHelper.CreateTempFile("This is just a note.")).SetFilename("note1.txt");
            Entity result = client.Operation("Blob.Attach")
                                  .SetInput(blob)
                                  .SetParameter("document", blobContainer.Path)
                                  .Execute()
                                  .Result;
            Assert.True(result is Blob);
            Assert.Equal("This is just a note.", IOHelper.ReadText(((Blob)result).File));

            BlobList blobs = new BlobList();
            blobs.Add(new Blob(IOHelper.CreateTempFile("This is another note.")).SetFilename("note2.txt"));
            blobs.Add(Blob.FromFile("Puppy.docx"));

            result = client.Operation("Blob.Attach")
                           .SetInput(blobs)
                           .SetParameter("document", blobContainer.Path)
                           .SetParameter("xpath", "files:files")
                           .Execute()
                           .Result;
            Assert.True(result is BlobList);
            Assert.Equal(2, blobs.Count);
            Assert.Equal("This is another note.", IOHelper.ReadText(blobs[0].File));
            Assert.True(IOHelper.AreFilesEqual("Puppy.docx", blobs[1].File.FullName));
        }

 public FourOhFourViewModel(FourOhFourReason reason, Blob blob)
 {
     Reason = reason;
     Blob = blob;
     Month = string.Empty;
     Year = DateTime.Now.Year.ToString(); 
 }

        public override bool Equals(Blob blob)
        {
            var sb = blob as StreamBlob;
            if (sb != null)
            {
                if (_stream == sb._stream) return true;
                var fsa = _stream as FileStream;
                if (fsa == null) return false;
                var fsb = sb._stream as FileStream;
                if (fsb == null) return false;
                try
                {
                    return fsa.Name.Equals(fsb.Name);
                }
                catch
                {
                    return false;
                }
            }

            var fb = blob as FileBlob;
            if (fb == null) return false;

            var fs = _stream as FileStream;
            if (fs == null) return false;
            try
            {
                return fb.Filename.Equals(fs.Name);
            }
            catch
            {
                return false;
            }
        }

        private static void WritePEImage(
            Stream peStream, 
            MetadataBuilder metadataBuilder, 
            BlobBuilder ilBuilder, 
            MethodDefinitionHandle entryPointHandle,
            Blob mvidFixup = default(Blob),
            byte[] privateKeyOpt = null)
        {
            var peBuilder = new ManagedPEBuilder(
                entryPointHandle.IsNil ? PEHeaderBuilder.CreateLibraryHeader() : PEHeaderBuilder.CreateExecutableHeader(),
                new MetadataRootBuilder(metadataBuilder),
                ilBuilder,
                entryPoint: entryPointHandle,
                flags: CorFlags.ILOnly | (privateKeyOpt != null ? CorFlags.StrongNameSigned : 0),
                deterministicIdProvider: content => s_contentId);

            var peBlob = new BlobBuilder();

            var contentId = peBuilder.Serialize(peBlob);

            if (!mvidFixup.IsDefault)
            {
                new BlobWriter(mvidFixup).WriteGuid(contentId.Guid);
            }

            if (privateKeyOpt != null)
            {
                peBuilder.Sign(peBlob, content => SigningUtilities.CalculateRsaSignature(content, privateKeyOpt));
            }

            peBlob.WriteContentTo(peStream);
        }

 public void EndTurnAction(Blob blob)
 {
     if (blob.Damage >= blob.InitialDamage + DamageReducedEveryTurn)
     {
         blob.Damage -= DamageReducedEveryTurn;
     }
 }

 /// <summary>
 /// Create a new KeyLocator with default values.
 /// </summary>
 ///
 public KeyLocator()
 {
     this.type_ = net.named_data.jndn.KeyLocatorType.NONE;
     this.keyData_ = new Blob();
     this.keyName_ = new ChangeCounter(new Name());
     this.changeCount_ = 0;
 }

		public IBlob Get(Uri uri)
		{
			IBlob blob = null;

			var options = new BlobRequestOptions { BlobListingDetails = BlobListingDetails.Metadata };

			var container = getContainer();
			var target = container.GetBlobReference(uri.ToString());

			try
			{
				target.FetchAttributes();
				blob = new Blob(target.Properties.ContentMD5, target.Properties.ETag)
					{ Content = target.DownloadByteArray(), ContentType = target.Properties.ContentType, };

				foreach (var key in target.Metadata.AllKeys)
				{
					blob.Metdata.Add(new KeyValuePair<string, string>(key, target.Metadata[key]));
				}
			}
			catch (StorageClientException s)
			{
				this.WriteErrorMessage(string.Format("An error occurred retrieving the blob from {0}", uri), s);
				blob = null;
			}

			return blob;
		}

 /// <summary>
 /// Create a new Interest with the given name and interest lifetime and "none"
 /// for other values.
 /// </summary>
 ///
 /// <param name="name">The name for the interest.</param>
 /// <param name="interestLifetimeMilliseconds"></param>
 public Interest(Name name, double interestLifetimeMilliseconds)
 {
     this.name_ = new ChangeCounter(new Name());
     this.minSuffixComponents_ = -1;
     this.maxSuffixComponents_ = -1;
     this.keyLocator_ = new ChangeCounter(
             new KeyLocator());
     this.exclude_ = new ChangeCounter(new Exclude());
     this.childSelector_ = -1;
     this.mustBeFresh_ = true;
     this.interestLifetimeMilliseconds_ = -1;
     this.nonce_ = new Blob();
     this.getNonceChangeCount_ = 0;
     this.lpPacket_ = null;
     this.linkWireEncoding_ = new Blob();
     this.linkWireEncodingFormat_ = null;
     this.link_ = new ChangeCounter(null);
     this.selectedDelegationIndex_ = -1;
     this.defaultWireEncoding_ = new SignedBlob();
     this.getDefaultWireEncodingChangeCount_ = 0;
     this.changeCount_ = 0;
     if (name != null)
         name_.set(new Name(name));
     interestLifetimeMilliseconds_ = interestLifetimeMilliseconds;
 }

        public async Task<Hash> PutAsync(long id, SemanticVersion version, IPackage package)
        {
            var key = prefix + id.ToString() + "/" + version.ToString();

            using (var ms = new MemoryStream())
            {
                await package.ZipToStreamAsync(ms).ConfigureAwait(false);

                ms.Position = 0;

                var hash = Hash.ComputeSHA256(ms, leaveOpen: true);

                var secret = SecretKey.Derive(password, hash.Data);

                using (var protector = new AesProtector(secret))
                {
                    using (var packageStream = protector.EncryptStream(ms))
                    {
                        var blob = new Blob(packageStream) {
                            ContentType = "application/zip"
                        };

                        await bucket.PutAsync(key, blob).ConfigureAwait(false);
                    }
                }

                return hash;
            }
        }

 /// <summary>
 /// Create a new HmacWithSha256Signature with default values.
 /// </summary>
 ///
 public HmacWithSha256Signature()
 {
     this.signature_ = new Blob();
     this.keyLocator_ = new ChangeCounter(
             new KeyLocator());
     this.changeCount_ = 0;
 }