GitSharp/Blob.cs

   1 /*
   2  * Copyright (C) 2009, Henon <meinrad.recheis@gmail.com>
   3  *
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or
   7  * without modification, are permitted provided that the following
   8  * conditions are met:
   9  *
  10  * - Redistributions of source code must retain the above copyright
  11  *   notice, this list of conditions and the following disclaimer.
  12  *
  13  * - Redistributions in binary form must reproduce the above
  14  *   copyright notice, this list of conditions and the following
  15  *   disclaimer in the documentation and/or other materials provided
  16  *   with the distribution.
  17  *
  18  * - Neither the name of the Git Development Community nor the
  19  *   names of its contributors may be used to endorse or promote
  20  *   products derived from this software without specific prior
  21  *   written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  24  * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  25  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  26  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  28  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  29  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  30  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  31  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  32  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  33  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  34  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  35  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36  */
  37
  38 using System;
  39 using System.Collections.Generic;
  40 using System.Linq;
  41 using System.Text;
  42 using GitSharp.Core.Util;
  43 using ObjectId = GitSharp.Core.ObjectId;
  44 using CoreRef = GitSharp.Core.Ref;
  45 using CoreCommit = GitSharp.Core.Commit;
  46 using CoreTree = GitSharp.Core.Tree;
  47 using CoreTag = GitSharp.Core.Tag;
  48 using System.IO;
  49
  50 namespace GitSharp
  51 {
  52         /// <summary>
  53         /// Represents a specific version of the content of a file tracked by git. Using a Blob you can access the contents of
  54         /// any git object as string or byte array. For tracked files (leaves of a git tree) it returns the content of the file. For git objects
  55         /// such as Commit, Tag or Tree the Blob API may be used to inspect the the uncompressed internal representation.
  56         /// <para/>
  57         /// To open a git object instantiate a Blob with the object's Hash or another valid reference (see Ref).
  58         /// <code>var b=new Blob(repo, "e287f54");</code>
  59         /// <para/>
  60         /// Note, that new Blob( ...) does not create a new blob in the repository but rather constructs the object to manipulate an existing blob.
  61         /// <para/>
  62         /// Advanced: To create a new Blob inside the repository you can use the static <see cref="Create(GitSharp.Repository,byte[])"/> function, however, you are advised to use
  63         /// higher level functionality to create new revisions of files, i.e. by using the <see cref="Commit"/> API, for instance <see cref="Commit.Create(string,GitSharp.Commit,GitSharp.Tree)"/>.
  64         /// </summary>
  65         public class Blob : AbstractObject
  66         {
  67
  68                 internal Blob(Repository repo, ObjectId id)
  69                         : base(repo, id)
  70                 {
  71                 }
  72
  73                 internal Blob(Repository repo, ObjectId id, byte[] blob)
  74                         : base(repo, id)
  75                 {
  76                         _blob = blob;
  77                 }
  78
  79                 /// <summary>
  80                 /// Create a Blob object which represents an existing blob in the git repository
  81                 /// </summary>
  82                 /// <param name="repo">The repository which owns the object to load</param>
  83                 /// <param name="hash">The SHA1 Hash of the object to load</param>
  84                 public Blob(Repository repo, string hash) : base(repo, hash) { }
  85
  86                 private byte[] _blob;
  87
  88                 /// <summary>
  89                 /// Get the uncompressed contents of this Blob as string. This assumes that the contents are encoded in UTF8.
  90                 /// </summary>
  91                 public string Data
  92                 {
  93                         get
  94                         {
  95                                 if (RawData == null)
  96                                         return null;
  97                                 return RawParseUtils.decode(RawData);
  98                         }
  99                 }
 100
 101                 /// <summary>
 102                 /// Get the uncompressed original encoded raw data of the Blob as byte array. This is useful if the contents of the blob are encoded in some legacy encoding instead of UTF8.
 103                 /// </summary>
 104                 public byte[] RawData
 105                 {
 106                         get
 107                         {
 108                                 if (_blob == null)
 109                                 {
 110                                         var loader = _repo._internal_repo.OpenBlob(_id);
 111                                         if (loader == null)
 112                                                 return null;
 113                                         _blob = loader.Bytes;
 114                                 }
 115                                 return _blob;
 116                         }
 117                 }
 118
 119                 public override string ToString()
 120                 {
 121                         return "Blob[" + ShortHash + "]";
 122                 }
 123
 124                 /// <summary>
 125                 /// Create a new Blob containing the given string data as content. The string will be encoded as UTF8
 126                 /// </summary>
 127                 /// <param name="repo"></param>
 128                 /// <param name="content">string to be stored in the blob</param>
 129                 /// <returns></returns>
 130                 public static Blob Create(Repository repo, string content)
 131                 {
 132                         return Create(repo, content, Encoding.UTF8);
 133                 }
 134
 135                 /// <summary>
 136                 /// Create a new Blob containing the given string data as content. The string will be encoded by the submitted encoding
 137                 /// </summary>
 138                 /// <param name="repo"></param>
 139                 /// <param name="content">string to be stored in the blob</param>
 140                 /// <param name="encoding"></param>
 141                 /// <returns></returns>
 142                 public static Blob Create(Repository repo, string content, Encoding encoding)
 143                 {
 144                         return Create(repo, encoding.GetBytes(content));
 145                 }
 146
 147                 /// <summary>
 148                 /// Create a new Blob containing the contents of the given file.
 149                 /// </summary>
 150                 /// <param name="repo"></param>
 151                 /// <param name="path">Path to the file that should be stored in the blob</param>
 152                 /// <returns></returns>
 153                 public static Blob CreateFromFile(Repository repo, string path)
 154                 {
 155                         if (new FileInfo(path).Exists == false)
 156                                 throw new ArgumentException("File does not exist", "path");
 157                         return Create(repo, File.ReadAllBytes(path));
 158                 }
 159
 160                 /// <summary>
 161                 /// Create a new Blob containing exactly the raw bytes given (before compression).
 162                 /// </summary>
 163                 /// <param name="repo"></param>
 164                 /// <param name="content">Uncompressed, encoded raw data to be stored in the blob</param>
 165                 /// <returns></returns>
 166                 public static Blob Create(Repository repo, byte[] content)
 167                 {
 168                         var db = repo._internal_repo;
 169                         var id = new GitSharp.Core.ObjectWriter(db).WriteBlob(content);
 170                         return new Blob(repo, id, content);
 171                 }
 172
 173         }
 174 }