| public static encode ( string str ) : byte[] | ||
| str | string | /// The string to convert. May contain any Unicode characters. /// |
| return | byte[] | |
private void ReadTree(string prefix, Tree t)
{
TreeEntry[] members = t.Members;
for (int i = 0; i < members.Length; ++i)
{
TreeEntry te = members[i];
string name;
if (prefix.Length > 0)
{
name = prefix + "/" + te.Name;
}
else
{
name = te.Name;
}
Tree tr = (te as Tree);
if (tr != null)
{
ReadTree(name, tr);
}
else
{
var e = new Entry(Repository, te, 0);
_entries[Constants.encode(name)] = e;
}
}
}
/// <summary>
/// Read the cache file into memory.
/// </summary>
/// <exception cref="IOException"> </exception>
public void Read()
{
_changed = false;
_statDirty = false;
_cacheFile.Refresh();
if (!_cacheFile.Exists)
{
_header = null;
_entries.Clear();
_lastCacheTime = 0;
return;
}
using (var cache = new FileStream(_cacheFile.FullName, System.IO.FileMode.Open))
using (var buffer = new EndianBinaryReader(new BigEndianBitConverter(), cache))
{
_header = new Header(buffer);
_entries.Clear();
for (int i = 0; i < _header.Entries; ++i)
{
var entry = new Entry(Repository, buffer);
_entries[Constants.encode(entry.Name)] = entry;
}
_lastCacheTime = _cacheFile.lastModified();
}
}
private static void AppendOneRecord(ObjectId oldId, ObjectId newId, PersonIdent ident, string msg, Repository db, string refName)
{
ident = ident == null ? new PersonIdent(db) : new PersonIdent(ident);
var r = new StringBuilder();
r.Append(ObjectId.ToString(oldId));
r.Append(' ');
r.Append(ObjectId.ToString(newId));
r.Append(' ');
r.Append(ident.ToExternalString());
r.Append('\t');
r.Append(msg);
r.Append('\n');
byte[] rec = Constants.encode(r.ToString());
var logdir = new DirectoryInfo(Path.Combine(db.Directory.FullName, Constants.LOGS));
var reflog = new FileInfo(Path.Combine(logdir.FullName, refName));
if (reflog.Exists || db.Config.getCore().isLogAllRefUpdates())
{
DirectoryInfo refdir = reflog.Directory;
if (!refdir.Exists && !refdir.Mkdirs())
{
throw new IOException("Cannot create directory " + refdir);
}
using (var @out = new FileStream(reflog.FullName, System.IO.FileMode.Append, FileAccess.Write))
{
@out.Write(rec, 0, rec.Length);
}
}
}
/**
* Rebuild the {@link Constants#INFO_REFS}.
* <para />
* This method rebuilds the contents of the {@link Constants#INFO_REFS} file
* to match the passed list of references.
*
*
* @
* writing is not supported, or attempting to write the file
* failed, possibly due to permissions or remote disk full, etc.
*/
public void writeInfoRefs()
{
StringBuilder w = new StringBuilder();
char[] tmp = new char[Constants.OBJECT_ID_LENGTH * 2];
foreach (Ref r in refs)
{
if (Constants.HEAD.Equals(r.Name))
{
// Historically HEAD has never been published through
// the INFO_REFS file. This is a mistake, but its the
// way things are.
//
continue;
}
r.ObjectId.CopyTo(tmp, w);
w.Append('\t');
w.Append(r.Name);
w.Append('\n');
if (r.PeeledObjectId != null)
{
r.PeeledObjectId.CopyTo(tmp, w);
w.Append('\t');
w.Append(r.Name);
w.Append("^{}\n");
}
}
writeFile(Constants.INFO_REFS, Constants.encode(w.ToString()));
}
/// <summary>
/// Construct and write tree out of index.
/// </summary>
/// <returns> SHA-1 of the constructed tree</returns>
/// <exception cref="IOException"></exception>
public ObjectId writeTree()
{
CheckWriteOk();
var writer = new ObjectWriter(Repository);
var current = new Tree(Repository);
var trees = new Stack <Tree>();
trees.Push(current);
var prevName = new string[0];
foreach (Entry e in _entries.Values)
{
if (e.Stage != STAGE_0)
{
continue;
}
string[] newName = SplitDirPath(e.Name);
int c = LongestCommonPath(prevName, newName);
while (c < trees.Count - 1)
{
current.Id = writer.WriteTree(current);
trees.Pop();
current = trees.Count == 0 ? null : trees.Peek();
}
while (trees.Count < newName.Length)
{
if (!current.ExistsTree(newName[trees.Count - 1]))
{
current = new Tree(current, Constants.encode(newName[trees.Count - 1]));
current.Parent.AddEntry(current);
trees.Push(current);
}
else
{
current = (Tree)current.findTreeMember(newName[trees.Count - 1]);
trees.Push(current);
}
}
var ne = new FileTreeEntry(current, e.ObjectId, Constants.encode(newName[newName.Length - 1]),
(e.Mode & FileMode.ExecutableFile.Bits) == FileMode.ExecutableFile.Bits);
current.AddEntry(ne);
}
while (trees.Count != 0)
{
current.Id = writer.WriteTree(current);
trees.Pop();
if (trees.Count != 0)
{
current = trees.Peek();
}
}
return(current.TreeId);
}
/// <summary>
/// Add tree entry to index
/// </summary>
/// <param name="te"> tree entry </param>
/// <returns> new or modified index entry </returns>
/// <exception cref="IOException"> </exception>
public Entry addEntry(TreeEntry te)
{
byte[] key = Constants.encode(te.FullName);
var e = new Entry(Repository, te, 0);
_entries[key] = e;
return(e);
}
/// <summary>
/// Writes a symref (e.g. HEAD) to disk
/// * @param name
/// </summary>
/// <param name="name">symref name</param>
/// <param name="target">pointed to ref</param>
public void Link(string name, string target)
{
lock (locker)
{
byte[] content = Constants.encode("ref: " + target + "\n");
LockAndWriteFile(FileForRef(name), content);
UncacheSymRef(name);
Repository.fireRefsMaybeChanged();
}
}
public bool Remove(string relative_file_path)
{
if (string.IsNullOrEmpty(relative_file_path))
{
return(false);
}
var key = Core.Repository.GitInternalSlash(Constants.encode(relative_file_path));
return(_entries.Remove(key));
}
private byte[] MakeKey(FileSystemInfo wd, FileSystemInfo f)
{
if (!string.IsNullOrEmpty(f.DirectoryName()) &&
wd.IsDirectory() && wd.Exists &&
!f.DirectoryName().StartsWith(wd.DirectoryName()))
{
throw new Exception("Path is not in working dir");
}
string relName = Repository.StripWorkDir(wd, f);
return(Core.Repository.GitInternalSlash(Constants.encode(relName)));
}
/**
* Rebuild the {@link Constants#PACKED_REFS} file.
* <para />
* This method rebuilds the contents of the {@link Constants#PACKED_REFS}
* file to match the passed list of references, including only those refs
* that have a storage type of {@link Ref.Storage#PACKED}.
*
* @
* writing is not supported, or attempting to write the file
* failed, possibly due to permissions or remote disk full, etc.
*/
public void writePackedRefs()
{
bool peeled = false;
foreach (Ref r in refs)
{
if (r.StorageFormat != Ref.Storage.Packed)
{
continue;
}
if (r.PeeledObjectId != null)
{
peeled = true;
}
}
StringBuilder w = new StringBuilder();
if (peeled)
{
w.Append("# pack-refs with:");
if (peeled)
{
w.Append(" peeled");
}
w.Append('\n');
}
char[] tmp = new char[Constants.OBJECT_ID_LENGTH * 2];
foreach (Ref r in refs)
{
if (r.StorageFormat != Ref.Storage.Packed)
{
continue;
}
r.ObjectId.CopyTo(tmp, w);
w.Append(' ');
w.Append(r.Name);
w.Append('\n');
if (r.PeeledObjectId != null)
{
w.Append('^');
r.PeeledObjectId.CopyTo(tmp, w);
w.Append('\n');
}
}
writeFile(Constants.PACKED_REFS, Constants.encode(w.ToString()));
}
/// <summary>
/// Rebuild the <see cref="Constants.PACKED_REFS"/> file.
/// <para />
/// This method rebuilds the contents of the <see cref="Constants.PACKED_REFS"/>
/// file to match the passed list of references, including only those refs
/// that have a storage type of <see cref="Storage.Packed"/>.
/// </summary>
public void writePackedRefs()
{
bool peeled = false;
foreach (Ref r in refs)
{
if (r.StorageFormat.IsPacked && r.IsPeeled)
{
peeled = true;
break;
}
}
var w = new StringBuilder();
if (peeled)
{
w.Append(RefDirectory.PACKED_REFS_HEADER);
if (peeled)
{
w.Append(RefDirectory.PACKED_REFS_PEELED);
}
w.Append('\n');
}
var tmp = new char[Constants.OBJECT_ID_STRING_LENGTH];
foreach (Ref r in refs)
{
if (r.StorageFormat != Storage.Packed)
{
continue;
}
r.ObjectId.CopyTo(tmp, w);
w.Append(' ');
w.Append(r.Name);
w.Append('\n');
if (r.PeeledObjectId != null)
{
w.Append('^');
r.PeeledObjectId.CopyTo(tmp, w);
w.Append('\n');
}
}
writeFile(Constants.PACKED_REFS, Constants.encode(w.ToString()));
}
public void save()
{
byte[] o = Constants.encode(toText());
using (LockFile lf = new LockFile(getFile()))
{
if (!lf.Lock())
{
throw new IOException("Cannot lock " + getFile());
}
lf.Write(o);
if (!lf.Commit())
{
throw new IOException("Cannot commit write to " + getFile());
}
}
}
/// <summary>
/// Create the <code>pack-*.keep</code> file, with the given message.
/// </summary>
/// <param name="msg">message to store in the file.</param>
/// <returns>
/// true if the keep file was successfully written; false otherwise.
/// </returns>
/// <exception cref="IOException">
/// The keep file could not be written.
/// </exception>
public bool Lock(string msg)
{
if (msg == null)
{
return(false);
}
if (!msg.EndsWith("\n"))
{
msg += "\n";
}
var lf = new LockFile(_keepFile);
if (!lf.Lock())
{
return(false);
}
lf.Write(Constants.encode(msg));
return(lf.Commit());
}
public void log(RefUpdate update, string msg, bool deref)
{
ObjectId oldId = update.getOldObjectId();
ObjectId newId = update.getNewObjectId();
Ref @ref = update.getRef();
PersonIdent ident = update.getRefLogIdent();
if (ident == null)
{
ident = new PersonIdent(parent);
}
else
{
ident = new PersonIdent(ident);
}
var r = new StringBuilder();
r.Append(ObjectId.ToString(oldId));
r.Append(' ');
r.Append(ObjectId.ToString(newId));
r.Append(' ');
r.Append(ident.ToExternalString());
r.Append('\t');
r.Append(msg);
r.Append('\n');
byte[] rec = Constants.encode(r.ToString());
if (deref && @ref.isSymbolic())
{
log(@ref.getName(), rec);
log(@ref.getLeaf().getName(), rec);
}
else
{
log(@ref.getName(), rec);
}
}
protected override RefUpdateResult doLink(string target)
{
_lock.setNeedStatInformation(true);
_lock.Write(Constants.encode(RefDirectory.SYMREF + target + '\n'));
string msg = getRefLogMessage();
if (msg != null)
{
_database.log(this, msg, false);
}
if (!_lock.Commit())
{
return(RefUpdateResult.LOCK_FAILURE);
}
_database.storedSymbolicRef(this, _lock.CommitLastModified, target);
if (Ref.getStorage() == Storage.New)
{
return(RefUpdateResult.NEW);
}
return(RefUpdateResult.FORCED);
}
internal Entry(Repository repository, TreeEntry f, int stage)
: this(repository)
{
Ctime = -1; // hmm
Mtime = -1;
_dev = -1;
_ino = -1;
Mode = f.Mode.Bits;
_uid = -1;
_gid = -1;
try
{
_size = (int)Repository.OpenBlob(f.Id).Size;
}
catch (IOException e)
{
e.printStackTrace();
_size = -1;
}
ObjectId = f.Id;
_name = Constants.encode(f.FullName);
_flags = (short)((stage << 12) | _name.Length); // TODO: fix _flags
}
/// <summary>
/// Adds a new or existing file with the specified name to this tree.
/// Trees are added if necessary as the name may contain '/':s.
/// </summary>
/// <param name="name"> Name </param>
/// <returns>A <seealso cref="FileTreeEntry"/> for the added file.</returns>
/// <exception cref="IOException"></exception>
public FileTreeEntry AddFile(string name)
{
return(AddFile(Repository.GitInternalSlash(Constants.encode(name)), 0));
}
/// <summary>
/// Look up an entry with the specified path.
/// </summary>
/// <param name="path"></param>
/// <returns>Index entry for the path or null if not in index.</returns>
public Entry GetEntry(string path)
{
byte[] val = Repository.GitInternalSlash(Constants.encode(path));
return(_entries.Where(e => e.Key.SequenceEqual(val)).FirstOrDefault().Value);
}
/// <summary>
/// Adds a new or existing Tree with the specified name to this tree.
/// Trees are added if necessary as the name may contain '/':s.
/// </summary>
/// <param name="name"></param>
/// <returns>A <seealso cref="FileTreeEntry"/> for the added tree.</returns>
/// <exception cref="IOException"> </exception>
public Tree AddTree(string name)
{
return(AddTree(Repository.GitInternalSlash(Constants.encode(name)), 0));
}
private TreeEntry FindMember(string s, byte slast)
{
return(FindMember(Repository.GitInternalSlash(Constants.encode(s)), slast, 0));
}
public void Rename(string n)
{
Rename(Constants.encode(n));
}