public virtual void TestUsingHiddenDeltaBaseFails() { byte[] delta = new byte[] { unchecked ((int)(0x1)), unchecked ((int)(0x1)), unchecked ( (int)(0x1)), (byte)('c') }; TestRepository <Repository> s = new TestRepository <Repository>(src); RevCommit N = s.Commit().Parent(B).Add("q", s.Blob(BinaryDelta.Apply(dst.Open(b). GetCachedBytes(), delta))).Create(); TemporaryBuffer.Heap pack = new TemporaryBuffer.Heap(1024); PackHeader(pack, 3); Copy(pack, src.Open(N)); Copy(pack, src.Open(s.ParseBody(N).Tree)); pack.Write((Constants.OBJ_REF_DELTA) << 4 | 4); b.CopyRawTo(pack); Deflate(pack, delta); Digest(pack); TemporaryBuffer.Heap inBuf = new TemporaryBuffer.Heap(1024); PacketLineOut inPckLine = new PacketLineOut(inBuf); inPckLine.WriteString(ObjectId.ZeroId.Name + ' ' + N.Name + ' ' + "refs/heads/s" + '\0' + BasePackPushConnection.CAPABILITY_REPORT_STATUS); inPckLine.End(); pack.WriteTo(inBuf, PM); TemporaryBuffer.Heap outBuf = new TemporaryBuffer.Heap(1024); ReceivePack rp = new ReceivePack(dst); rp.SetCheckReceivedObjects(true); rp.SetCheckReferencedObjectsAreReachable(true); rp.SetRefFilter(new ReceivePackRefFilterTest.HidePrivateFilter()); try { Receive(rp, inBuf, outBuf); NUnit.Framework.Assert.Fail("Expected UnpackException"); } catch (UnpackException failed) { Exception err = failed.InnerException; NUnit.Framework.Assert.IsTrue(err is MissingObjectException); MissingObjectException moe = (MissingObjectException)err; NUnit.Framework.Assert.AreEqual(b, moe.GetObjectId()); } PacketLineIn r = AsPacketLineIn(outBuf); string master = r.ReadString(); int nul = master.IndexOf('\0'); NUnit.Framework.Assert.IsTrue(nul > 0, "has capability list"); NUnit.Framework.Assert.AreEqual(B.Name + ' ' + R_MASTER, Sharpen.Runtime.Substring (master, 0, nul)); NUnit.Framework.Assert.AreSame(PacketLineIn.END, r.ReadString()); NUnit.Framework.Assert.AreEqual("unpack error Missing blob " + b.Name, r.ReadString ()); NUnit.Framework.Assert.AreEqual("ng refs/heads/s n/a (unpacker error)", r.ReadString ()); NUnit.Framework.Assert.AreSame(PacketLineIn.END, r.ReadString()); }
public void Open() { CreateRequestsInRepository(new[] { new DateTime(2014, 1, 1) }, new[] { 10 }); Repository.Close(); Context.ClearReceivedCalls(); Repository.Open(DatabaseFile); Context.Received(1).UpdateRecentAccountInformation(Repository.FilePath); AssertRepositoryEqualsFileContent(DatabaseFile); Assert.That(Repository.FilePath, Is.EqualTo(DatabaseFile)); }
internal static Repository Get(string key) { var repo = Repositories.GetOrAdd(key, s => { var so = new GridStructure(); var instance = new Repository(); instance.Open <GeoGrillas>(Config.Qtree.QtreeDirectory, ref so); return(instance); }); return(repo); }
/// <summary> /// Updates the file in the working tree with content and mode from an entry /// in the index. /// </summary> /// <remarks> /// Updates the file in the working tree with content and mode from an entry /// in the index. The new content is first written to a new temporary file in /// the same directory as the real file. Then that new file is renamed to the /// final filename. /// TODO: this method works directly on File IO, we may need another /// abstraction (like WorkingTreeIterator). This way we could tell e.g. /// Eclipse that Files in the workspace got changed /// </remarks> /// <param name="repo"></param> /// <param name="f"> /// the file to be modified. The parent directory for this file /// has to exist already /// </param> /// <param name="entry">the entry containing new mode and content</param> /// <exception cref="System.IO.IOException">System.IO.IOException</exception> public static void CheckoutEntry(Repository repo, FilePath f, DirCacheEntry entry ) { ObjectLoader ol = repo.Open(entry.GetObjectId()); FilePath parentDir = f.GetParentFile(); FilePath tmpFile = FilePath.CreateTempFile("._" + f.GetName(), null, parentDir); FileOutputStream channel = new FileOutputStream(tmpFile); try { ol.CopyTo(channel); } finally { channel.Close(); } FS fs = repo.FileSystem; WorkingTreeOptions opt = repo.GetConfig().Get(WorkingTreeOptions.KEY); if (opt.IsFileMode() && fs.SupportsExecute()) { if (FileMode.EXECUTABLE_FILE.Equals(entry.RawMode)) { if (!fs.CanExecute(tmpFile)) { fs.SetExecute(tmpFile, true); } } else { if (fs.CanExecute(tmpFile)) { fs.SetExecute(tmpFile, false); } } } if (!tmpFile.RenameTo(f)) { // tried to rename which failed. Let' delete the target file and try // again FileUtils.Delete(f); if (!tmpFile.RenameTo(f)) { throw new IOException(MessageFormat.Format(JGitText.Get().couldNotWriteFile, tmpFile .GetPath(), f.GetPath())); } } entry.LastModified = f.LastModified(); entry.SetLength((int)ol.GetSize()); }
private static Repository InitializeRepository(DependencyArguments dependencyArguments, string commandLineArguments) { Repository repository = new Repository(dependencyArguments.depDb); try { repository.Open(); // check if this is a valid repository database if (repository.IsValidRepository() == false) { repository.CreateRepository(); } if (dependencyArguments.clearDatabase) { repository.DeleteExistingRepository(); } else { repository.LoadExisingRepository(); } if (commandLineArguments.Length > 512) { repository.InitialiseRepository(commandLineArguments.Substring(0, 512)); } else { repository.InitialiseRepository(commandLineArguments); } repository.DatabaseNameOnlyCompare = dependencyArguments.matchDBOnly; foreach (string dbPrefix in dependencyArguments.dbPrefix) { repository.DatabasePrefixExclusions.Add(dbPrefix); } return(repository); } catch (Exception ex) { log.Error(string.Format("Unable to connect to Dependency Database: {0}", dependencyArguments.depDb)); log.Error(string.Format("Message: {0}", ex.Message)); return(null); } }
public static ObjectLoader open(this Repository repository, string sha1) { try { if (repository.notNull()) { var objectId = sha1.objectId(); if (objectId.valid()) { return(repository.Open(objectId)); } } } catch (Exception ex) { ex.log("[API_NGit][open]"); } return(null); }
public static DisgaeaProject GetProject(string path) { Repository repository; if (File.Exists(path)) { repository = Repository.Open(path); } else { repository = Repository.Create(path); repository.InsertConfig("OUTPUT_REPLACEMENT", "1"); repository.InsertConfig("OUTPUT_ENCODING", "UTF-8"); repository.InsertReplacement("á", "a"); repository.InsertReplacement("é", "e"); repository.InsertReplacement("í", "i"); repository.InsertReplacement("ó", "o"); repository.InsertReplacement("ú", "u"); repository.InsertReplacement("ü", "u"); repository.InsertReplacement("Á", "A"); repository.InsertReplacement("É", "E"); repository.InsertReplacement("Í", "I"); repository.InsertReplacement("Ó", "O"); repository.InsertReplacement("Ú", "U"); repository.InsertReplacement("Ü", "U"); repository.InsertReplacement("ñ", "n"); repository.InsertReplacement("Ñ", "N"); repository.InsertReplacement("¡", "!"); repository.InsertReplacement("¿", "?"); } var result = new DisgaeaProject(repository) { Path = path }; return(result); }
public QtreeInstanceManager(DAOFactory factory) { _factory = factory; var coches = _factory.CocheDAO.GetList(new[] { -1 }, new[] { -1 }); foreach (var c in coches) { var key = c.Dispositivo.GetQtreeType() + "|" + c.Dispositivo.GetQtreeFile(); var repo = repositories.GetOrAdd(key, s => { var so = new GridStructure(); var instance = new Repository(); instance.Open <GeoGrillas>(Config.Qtree.QtreeDirectory, ref so); return(instance); }); speedSpecs.TryAdd(c.Id, DispositivoSpeedSpec.Build(c.Dispositivo, repo)); } }
public static string GetFileContent(this RevCommit commit, string path, Repository repository) { var treeWalk = new TreeWalk(repository) {Recursive = true, Filter = PathFilter.Create(path)}; treeWalk.AddTree(commit.Tree); if (!treeWalk.Next()) { return string.Empty; } var objectId = treeWalk.GetObjectId(0); var loader = repository.Open(objectId); using (var stream = loader.OpenStream()) { using (var reader = new StreamReader(stream)) { return reader.ReadToEnd(); } } }
private static string GetSnapshot(Repository repository, Git git, RevTree revTree, String file) { //Get snapshot , Retrive older version of an object TreeWalk treeWalk = TreeWalk.ForPath(git.GetRepository(), file, revTree); byte[] data = repository.Open(treeWalk.GetObjectId(0)).GetBytes(); return(System.Text.Encoding.UTF8.GetString(data)); //ObjectLoader loader = repository.Open(rev.ToObjectId()); //InputStream ttt = loader.OpenStream(); //string result = ttt.ToString(); //Retrive older version of an object //RevTree revTree = rev.Tree; //TreeWalk treeWalk = new TreeWalk(git.GetRepository()); //treeWalk.AddTree(revTree); //while (treeWalk.Next()) //{ // //compare treeWalk.NameString yourself // byte[] bytes = treeWalk.ObjectReader.Open(rev.ToObjectId()).GetCachedBytes(); // string result = System.Text.Encoding.UTF8.GetString(rev.RawBuffer); //} }
public static SRRProject GetProject(string path) { Repository repository; if (File.Exists(path)) { repository = Repository.Open(path); } else { repository = Repository.Create(path); repository.InsertConfig("OUTPUT_REPLACEMENT", "0"); repository.InsertConfig("OUTPUT_ENCODING", "UTF-8"); } var result = new SRRProject(repository) { Path = path }; return(result); }
/// <summary>Check out content of the specified index entry</summary> /// <param name="wd">workdir</param> /// <param name="e">index entry</param> /// <exception cref="System.IO.IOException">System.IO.IOException</exception> public virtual void CheckoutEntry(FilePath wd, GitIndex.Entry e) { ObjectLoader ol = db.Open(e.sha1, Constants.OBJ_BLOB); FilePath file = new FilePath(wd, e.GetName()); file.Delete(); FileUtils.Mkdirs(file.GetParentFile(), true); FileOutputStream dst = new FileOutputStream(file); try { ol.CopyTo(dst); } finally { dst.Close(); } if (Config_filemode() && File_hasExecute()) { if (FileMode.EXECUTABLE_FILE.Equals(e.mode)) { if (!File_canExecute(file)) { File_setExecute(file, true); } } else { if (File_canExecute(file)) { File_setExecute(file, false); } } } e.mtime = file.LastModified() * 1000000L; e.ctime = e.mtime; }
static void Main(string[] args) { Repository repo = Repository.Open(@"C:\Projects\dotGit"); Console.WriteLine(repo.Storage); WalkTree(repo.HEAD.Commit.Tree, 0); //dotGit.Objects.Storage.Pack.LoadPack(System.IO.Path.Combine(repo.GitDir.FullName, "objects\\pack\\pack-209b24047b294e1d9a97680d62a5b9e1d4bef33c")); //Tag firstTag = repo.Tags["0.1-alpha"]; //Branch master = repo.Branches["master"]; Console.WriteLine(repo.HEAD.Commit.Tree.Children); //IStorableObject obj = repo.Storage.GetObject("bf6ae5d04bcd11d035be3654973ff5339d3f4e1b"); //Index idx = repo.Index; //TreeNodeCollection nodes = repo.HEAD.Commit.Tree.Children; //Commit obj = repo.Storage.GetObject<Commit>("5202e973f3d38c583b1a4645d23a638acc012c41"); //Blob b = repo.Storage.GetObject<Blob>("58d11b659b2c71a0cbdc0d037e237243cfec8a88"); //IStorableObject o = repo.Storage.GetObject("54040746289fd8beff929bcdcdd2b33be8a3700b"); //foreach (Tag tag in repo.Tags) //{ // Console.WriteLine(String.Format("Tag: '{0}' points to {1}", tag.Name, tag.SHA)); //} Console.ReadLine(); }
public static ShenmueProject GetProject(string path) { Repository repository; if (File.Exists(path)) { repository = Repository.Open(path); } else { repository = Repository.Create(path); repository.InsertConfig("OUTPUT_REPLACEMENT", "1"); repository.InsertConfig("OUTPUT_ENCODING", "UTF-8"); repository.InsertReplacement("á", "à"); repository.InsertReplacement("í", "ï"); repository.InsertReplacement("ó", "ô"); repository.InsertReplacement("ú", "ù"); repository.InsertReplacement("ü", "ë"); repository.InsertReplacement("Ú", "û"); repository.InsertReplacement("ñ", "â"); repository.InsertReplacement("¡", "Î"); repository.InsertReplacement("¿", "Ê"); } var result = new ShenmueProject(repository) { Path = path }; return(result); }
} // End Function GetDiff // https://stackoverflow.com/questions/13537734/how-to-use-jgit-to-get-list-of-changed-files // https://github.com/centic9/jgit-cookbook/blob/master/src/main/java/org/dstadler/jgit/porcelain/ShowChangedFilesBetweenCommits.java public static void GetChanges(Git git, Repository repo, RevCommit oldCommit, RevCommit newCommit) { System.Console.WriteLine("Printing diff between commit: " + oldCommit.ToString() + " and " + newCommit.ToString()); ObjectReader reader = repo.NewObjectReader(); // prepare the two iterators to compute the diff between CanonicalTreeParser oldTreeIter = new CanonicalTreeParser(); oldTreeIter.Reset(reader, oldCommit.Tree.Id); CanonicalTreeParser newTreeIter = new CanonicalTreeParser(); newTreeIter.Reset(reader, newCommit.Tree.Id); // DiffStatFormatter df = new DiffStatFormatter(newCommit.Name, repo); using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) { DiffFormatter diffFormatter = new DiffFormatter(ms); diffFormatter.SetRepository(repo); int entryCount = 0; foreach (DiffEntry entry in diffFormatter.Scan(oldCommit, newCommit)) { string pathToUse = null; TreeWalk treeWalk = new TreeWalk(repo); treeWalk.Recursive = true; if (entry.GetChangeType() == DiffEntry.ChangeType.DELETE) { treeWalk.AddTree(oldCommit.Tree); pathToUse = entry.GetOldPath(); } else { treeWalk.AddTree(newCommit.Tree); pathToUse = entry.GetNewPath(); } treeWalk.Filter = PathFilter.Create(pathToUse); if (!treeWalk.Next()) { throw new System.Exception("Did not find expected file '" + pathToUse + "'"); } ObjectId objectId = treeWalk.GetObjectId(0); ObjectLoader loader = repo.Open(objectId); string strModifiedFile = ReadFile(loader); System.Console.WriteLine(strModifiedFile); ////////////// // https://stackoverflow.com/questions/27361538/how-to-show-changes-between-commits-with-jgit diffFormatter.Format(diffFormatter.ToFileHeader(entry)); string diff = GetDiff(repo, entry); System.Console.WriteLine(diff); entryCount++; } // Next entry System.Console.WriteLine(entryCount); ms.Position = 0; using (System.IO.StreamReader sr = new System.IO.StreamReader(ms)) { string strAllDiffs = sr.ReadToEnd(); System.Console.WriteLine(strAllDiffs); } // End Using sr } // End Using ms System.Collections.Generic.IList<DiffEntry> diffs = git.Diff() .SetNewTree(newTreeIter) .SetOldTree(oldTreeIter) .Call(); foreach (DiffEntry entry in diffs) { System.Console.WriteLine("Entry: " + entry); System.Console.WriteLine("Entry: " + entry.GetChangeType()); } // Next entry System.Console.WriteLine("Done"); } // End Sub GetChanges
public void Refresh() { this.index = null; this.commitTree = null; this.cache.Clear(); this.changedFiles = null; this.repositoryGraph = null; this.dirCache = null; this.head = null; this.ignoreRules = null; this.remotes = null; this.configs = null; if (!string.IsNullOrEmpty(initFolder)) { try { this.repository = Open(new DirectoryInfo(initFolder)); if (this.repository != null) { dirCache = repository.ReadDirCache(); head = repository.Resolve(Constants.HEAD); if (head == null) { this.commitTree = new Tree(repository); } else { var treeId = ObjectId.FromString(repository.Open(head).GetBytes(), 5); this.commitTree = new Tree(repository, treeId, repository.Open(treeId).GetBytes()); } if (repository.IsBare) throw new NoWorkTreeException(); this.index = new GitIndex(repository); this.index.Read(); this.index.RereadIfNecessary(); try { //load local .gitignore file var ignoreFile = Path.Combine(this.initFolder, Constants.GITIGNORE_FILENAME); if (File.Exists(ignoreFile)) { ignoreRules = File.ReadAllLines(ignoreFile) .Where(line => !line.StartsWith("#") && line.Trim().Length > 0) .Select(line => new IgnoreRule(line)).ToList(); } } catch (Exception ex) { Log.WriteLine("ReadIgnoreFile: {0}\r\n{1}", this.initFolder, ex.ToString()); } } } catch (Exception ex) { this.repository = null; Log.WriteLine("Refresh: {0}\r\n{1}", this.initFolder, ex.ToString()); } } }
public void TestDirectoryHierarchy() { var fileSystem = new Repository(); var nodeOne = new LocalFileTree(); var nodeTwo = new LocalFileTree(); var nodeThree = new ZipNodeTree(); string appPath = Path.Combine(TestingUtils.GetTestingBaseFolder(), "testdata"); var tempDir = Path.Combine(Path.Combine(appPath, @"Data2\temp")); if (Directory.Exists(tempDir)) { Directory.Delete(tempDir, true); } Assert.IsTrue(nodeOne.Build(Path.Combine(appPath, @"Data\"))); Assert.IsTrue(nodeTwo.Build(Path.Combine(appPath, @"Data2\"))); Assert.IsTrue(nodeThree.Build(Path.Combine(appPath, @"Data.zip"))); fileSystem.AddSystem("First", nodeOne); fileSystem.AddSystem("Second", nodeTwo); fileSystem.AddSystem("Third", nodeThree); Assert.IsTrue(fileSystem.DirExists(@"subfolder01")); Assert.IsTrue(fileSystem.DirExists(@"subfolder02")); Assert.IsTrue(fileSystem.DirExists(@"alphabetagamma")); Assert.IsTrue(fileSystem.DirExists(@"subfolder02\subfolder_a")); Assert.IsTrue(fileSystem.DirExists(@"subfolder02\subfolder_a\subfolder_a_b")); Assert.IsTrue(fileSystem.DirExists(@"subfolder02\subfolder_a\subfolder_a_c")); Assert.IsTrue(fileSystem.FileExists(@"colours.txt")); Assert.IsTrue(fileSystem.FileExists(@"File01.txt")); Assert.IsTrue(fileSystem.FileExists(@"subfolder02\booga.txt")); Assert.IsTrue(fileSystem.FileExists(@"subfolder02\subfolder_a\geoip.txt")); Assert.IsTrue(fileSystem.FileExists(@"subfolder02\subfolder_a\subfolder_a_b\another_test.folder.txt")); Assert.IsTrue(fileSystem.FileExists(@"subfolder01\map01.txt")); // Get Data from various filesystems // This should be coming from nodeOne using (Stream fs = fileSystem.Open(@"alphabetagamma\db.sample.txt")) { byte[] buffer = new byte[1024]; UTF8Encoding temp = new UTF8Encoding(true); int amountRead = fs.Read(buffer, 0, buffer.Length); int accumulation = amountRead; while (amountRead > 0) { string contents = temp.GetString(buffer, 0, amountRead); Console.Write(contents); amountRead = fs.Read(buffer, 0, buffer.Length); accumulation += amountRead; } Console.WriteLine(""); Console.WriteLine("Read {0} bytes", accumulation); } // This should be coming from nodeTwo using (Stream fs = fileSystem.Open(@"File01.txt")) { byte[] buffer = new byte[1024]; UTF8Encoding temp = new UTF8Encoding(true); int amountRead = fs.Read(buffer, 0, buffer.Length); int accumulation = amountRead; while (amountRead > 0) { string contents = temp.GetString(buffer, 0, amountRead); Console.Write(contents); amountRead = fs.Read(buffer, 0, buffer.Length); accumulation += amountRead; } Console.WriteLine(""); Console.WriteLine("Read {0} bytes", accumulation); } // This should be coming from nodeThree using (Stream fs = fileSystem.Open(@"subfolder02\subfolder_a\subfolder_a_c\data.data.data.txt")) { byte[] buffer = new byte[1024]; UTF8Encoding temp = new UTF8Encoding(true); int amountRead = fs.Read(buffer, 0, buffer.Length); int accumulation = amountRead; while (amountRead > 0) { string contents = temp.GetString(buffer, 0, amountRead); Console.Write(contents); amountRead = fs.Read(buffer, 0, buffer.Length); accumulation += amountRead; } Console.WriteLine(""); Console.WriteLine("Read {0} bytes", accumulation); } // Write a file - this should go into nodeTwo Byte[] info = new UTF8Encoding(true).GetBytes("This is a test of data being written into the FileSystem."); Assert.IsTrue(fileSystem.Write(@"temp\sample_file.txt", info, info.Length)); Assert.IsTrue(fileSystem.FileExists(@"temp\sample_file.txt")); Assert.IsTrue(nodeTwo.FileExists(@"temp\sample_file.txt")); Assert.IsTrue(fileSystem.Delete(@"temp\sample_file.txt")); }
protected Repository SandboxRepository(string resource) { return(Repository.Open(SandboxResource(resource))); }
public void Refresh() { this.cache.Clear(); this.changedFiles = null; this.repositoryGraph = null; if (!string.IsNullOrEmpty(initFolder)) { try { this.repository = Git.Open(initFolder).GetRepository(); if (this.repository != null) { var id = repository.Resolve(Constants.HEAD); //var commit = repository.MapCommit(id); //this.commitTree = (commit != null ? commit.TreeEntry : new Tree(repository)); if (id == null) { this.commitTree = new Tree(repository); } else { var treeId = ObjectId.FromString(repository.Open(id).GetBytes(), 5); this.commitTree = new Tree(repository, treeId, repository.Open(treeId).GetBytes()); } this.index = repository.GetIndex(); this.index.RereadIfNecessary(); ignoreRules = File.ReadAllLines(Path.Combine(this.initFolder, Constants.GITIGNORE_FILENAME)) .Where(line => !line.StartsWith("#") && line.Trim().Length > 0) .Select(line => new IgnoreRule(line)).ToList(); } } catch (Exception ex) { } } }
/// <exception cref="System.IO.IOException"></exception> private static RawText GetRawText(ObjectId id, Repository db) { if (id.Equals(ObjectId.ZeroId)) { return new RawText(new byte[] { }); } return new RawText(db.Open(id, Constants.OBJ_BLOB).GetCachedBytes()); }
static void Main(string[] args) { Console.Write("QuadTree Tester Inicializando v 1.0\r\n"); string basedir = @"C:\QTREE_REPO"; var repo = new Repository(); if (!System.IO.Directory.Exists(basedir)) { Console.Write("El repositorio [{0}] no existe, lo creamos.\r\n", basedir); StorageGeometry sgeom = new StorageGeometry() { Signature = "0123456789ABCDEF", CellBits = (char)4, ActiveKey = 0x55AA55AA, DataStart = 2, FileSectorCount = 64, Lat_OffSet = 340000000, Lon_OffSet = 580000000, Lat_Grid = 5000, Lon_Grid = 5000, Lat_GridCount = 2000, Lon_GridCount = 2000 }; if (!repo.Init(basedir, sgeom)) { Console.Write("Imposible inicializar el repositorio GR2\r\n"); Console.ReadLine(); return; } } StorageGeometry sgeom2 = new StorageGeometry(); if (!repo.Open(basedir, ref sgeom2)) { Console.Write("El repositorio GR2 parece corrupto.\r\n"); Console.ReadLine(); return; } Console.WriteLine("Header Signature: {0}", sgeom2.Signature); Console.ReadLine(); var Cartografia = new Cartografia("C:\\MapasCopia"); foreach (var map in Cartografia) { for (int j = map.Poligonos.Count - 1; j >= 0; j--) { var poligono = map.Poligonos[j]; if (poligono.Nivel != 5000) { continue; } int[] vertices = map.Poligonos.GetVertices(j); for (int i = 0; i < vertices.Length; i++) { var vertex = vertices[i]; var lonlat = new LonLat(map.Coords[vertex]); //6T.TRACE("Creando vertice #{0} {1} {2}", vertex, lonlat.Latitud, lonlat.Longitud); repo.SetPositionClass((float)lonlat.Latitud, (float)lonlat.Longitud, 1); var Gr2Cache = repo.IndexCatalog.OfType <GR2>().FirstOrDefault(); Gr2Cache.SetReference((float)lonlat.Latitud, (float)lonlat.Longitud, "v", map.Vertices[vertex]); } } } repo.SetPositionClass(34.5665F, 55.2235F, 12); int clase = repo.GetPositionClass(34.5665F, 55.2235F); var Gr2Cache2 = repo.IndexCatalog.OfType <GR2>().FirstOrDefault(); var rd = Gr2Cache2.GetReference <Vertice>(34.5665F, 55.2235F, "vertices"); Vertice ppp = new Vertice() { Tipo = 22123123, Prioridad = 1234, NReg = 2357 }; Gr2Cache2.SetReference(34.5665F, 55.2235F, "vertices", ppp); Console.Write("sample: clase leida {0}\r\n", clase); Console.Write("\r\n"); /* * qtree.SetPositionClass(34.2665, 55.4235, 3); * qtree.SetPositionClass(34.267, 55.4235, 4); * qtree.SetPositionClass(34.268, 55.4235, 5); * qtree.SetPositionClass(34.269, 55.4235, 6); * qtree.SetPositionClass(34.270, 55.4235, 7); * qtree.SetPositionClass(34.271, 55.4235, 8); * * clase = qtree.GetPositionClass(34.2665, 55.4235); * Console.Write("sample: clase leida {0}\r\n", clase); * Console.Write("\r\n"); * * clase = qtree.GetPositionClass(34.5665, 55.2235); * Console.Write("sample: clase leida {0}\r\n", clase); * Console.Write("\r\n"); * * clase = qtree.GetPositionClass(34.2665, 55.4235); * Console.Write("sample: clase leida {0}\r\n", clase); * Console.Write("\r\n"); * * qtree.SetPositionClass(37.5665, 55.2235, 12); * clase = qtree.GetPositionClass(37.5665, 55.2235); * Console.Write("sample: clase leida {0}\r\n", clase); * Console.Write("\r\n"); * * qtree.SetPositionClass(37.2665, 55.4235, 3); * clase = qtree.GetPositionClass(37.2665, 55.4235); * * Console.Write("sample: clase leida {0}\r\n", clase); * Console.Write("\r\n"); * * clase = qtree.GetPositionClass(37.5665, 55.2235); * Console.Write("sample: clase leida {0}\r\n", clase); * Console.Write("\r\n"); * * clase = qtree.GetPositionClass(37.2665, 55.4235); * Console.Write("sample: clase leida {0}\r\n", clase); * Console.Write("\r\n"); * * qtree.SetPositionClass(37.2665, 55.4235, 8); * clase = qtree.GetPositionClass(37.2665, 55.4235); * Console.Write("sample: clase leida {0}\r\n", clase); * Console.Write("\r\n"); * * qtree.SetPositionClass(34.0, 55.0, 4); * qtree.SetPositionClass(34.99999, 55.99999, 4); * * qtree.SetPositionClass(46.5, 65.5, 5); * qtree.SetPositionClass(47.2, 56.4, 15); */ repo.Close(); Console.ReadLine(); }
public void Refresh() { this.cache.Clear(); this.changedFiles = null; if (!string.IsNullOrEmpty(initFolder)) { try { this.repository = Git.Open(initFolder).GetRepository(); if (this.repository != null) { var id = repository.Resolve(Constants.HEAD); //var commit = repository.MapCommit(id); //this.commitTree = (commit != null ? commit.TreeEntry : new Tree(repository)); if (id == null) { this.commitTree = new Tree(repository); } else { var treeId = ObjectId.FromString(repository.Open(id).GetBytes(), 5); this.commitTree = new Tree(repository, treeId, repository.Open(treeId).GetBytes()); } this.index = repository.GetIndex(); this.index.RereadIfNecessary(); } } catch (Exception ex) { } } }