For years Iām contemplating about a countable subset of R, bigger than Q: The set of numbers which can be determined with a finite number of characters. This set (I call it R- or sub-transcendental numbers) is obviously countable.
What are the properties of R-?
What are the properties of R \ R- (I call it R+): A number of R+ cannot be described with a finite number of characters (in no way). You cannot grasp a number in R+ (if you could, it would be in R-)
See here the beginning of a paper (not too serious) in which I try to formalise my thoughts.
Install Git 1.9.2 on CentOS on Google Compute Engine
I just installed Git 1.9.2 on a Google Compute Engine virtual machine running CentOS.
These were the steps which led to success:
At first I followed the steps from Jonathan Mark Smith for Git 1.8.2:
yum install gettext-devel expat-devel curl-devel zlib-devel openssl-devel
cd /usr/local/src
wget https://www.kernel.org/pub/software/scm/git/git-1.9.2.tar.gz
tar xzvf git-1.9.2.tar.gz
cd git-1.9.2
make prefix=/usr/local all
make prefix=/usr/local install
But I got an error saying something like 'Can't locate ExtUtils/MakeMaker.pm'.
Shoot!
Google to my rescue I found a great post on Mad Coder's Blog with the following advice:
yum install perl-devel
Now I ran the last two make commands again and I was fine.
make prefix=/usr/local all
make prefix=/usr/local install
But we faced some problems with the row selection via mouse click in a row.
In columns with cellEditors it worked quite poorly.
The reason of this poor behaviour lies in the Primefaces JavaScript code
It does not process the clicks on cells with cell editors,
because these cells contains a "div", which are not
recognized by the "onRowClick" method of the DataTable object.
To see this you have to create a Primefaces jar with non minified JavaScript
code as explained in a
great blog post from Rudy De Busscher.
Armored with this and a Firebug it's easy to find that in
META-INF/resources/primefaces/primefaces.js
the div-element, which is used in the columns with cell editors, is
blocked in the 'onRowClick' method of the DataTable:
--amending my last post, I changed the script to search for lost files in the git dungeon.
It now searches all packed objects too (again based on stackoverflow.com
from willkil)
The parameters have not changed.
See my last post for a short description.
You can find the script on GitHub.
There is also an even smaller script,
which gets you rid of all the branches the search script may have created.
(Btw.: I changed the hashbang from /opt/local/bin/perl (OS X) to /usr/bin/perl (Linux).
You may change it to what fits for you.)
#!/usr/bin/perl
my $type = $ARGV[0]; # 'tree' or 'blob'?
my $pattern = $ARGV[1]; # filename to search for as regex
my $createBranches = $ARGV[2]; # 'y' if you want to create branches (only when search for 'tree')
##################################################################
# find all objects (blobs, trees, commits, tags) in .git/objects
##################################################################
my %AllSha1;
# scan the packed and non-packed files
my @AllFiles = `find .git/objects/`;
for my $f (@AllFiles) {
if($f =~ /([0-9a-f][0-9a-f])\/([0-9a-f]{38})/) {
# non-packed
my $sha1 = $1 . $2;
$AllSha1{$sha1} = 1;
}
elsif($f =~ /idx$/) {
# packed
my @IndexContent = `git show-index < $f`;
for my $indexLine (@IndexContent) {
my @IndexLineParts = split(/ /, $indexLine);
my $sha1 = $IndexLineParts[1];
$AllSha1{$sha1} = 1;
}
}
}
##################################################################
# find all trees or blobs containing the pattern
##################################################################
my $ctr = 0;
for my $foundSha1 (keys %AllSha1) {
chomp $foundSha1;
next if length($foundSha1) == 0;
my $t = `git cat-file -t $foundSha1`;
chomp $t;
if($t eq $type) {
my @Lines = `git cat-file -p $foundSha1`;
for my $line (@Lines) {
if($line =~ /$pattern/) {
$ctr++;
printf "found $type: %s\n", $foundSha1;
if($type eq 'tree' && $createBranches eq 'y') {
my $branchName = sprintf "found/%03s", $ctr;
printf "created branch: %s\n", $branchName;
my $commitSha1 = `git commit-tree $foundSha1 -m "found $pattern"`;
`git branch $branchName $commitSha1`;
}
last;
}
}
}
}
Last year I posted a
script to find lost files deep in the .git/objects folder.
But the way I chose was not the smartest:
It scanned all tree objects for a given file name (or pattern)
and searched for commits pointing to this tree.
But since only the root tree has a commit pointing to it the script could only find
files in the root folder.
That was dumb from my side. So I fixed it and made it much simpler:
It searches for trees or blobs containing the given pattern (it could also search for commits or tags if you wanted to)
It it finds a blob it just logs it out
If it finds a tree it creates a commit pointing to it via 'git commit-tree' and a branch pointing to this tree
Searching for the contents of blobs may be necessary. E.g. if the file you are searching for never made it into a commit,
but was part of the index (and therefore could be somewhere in the object store if the gc has not already removed it).
The script
The script has 3 parameters:
The object type to search in. Can be 'tree', 'blob', 'tag' or 'commit'
The pattern to search for
'y' if you want to create commits and branches (only when type='tree')
The script is super simple, has no bells and zero whistles. So feel free to --amend it.
You can also find it on Github (in its newest version)
Possible improvements
Galore!
Just some examples:
Make it more convenient: Use options, print a help text, ...
Search also in the pack file
To make it faster: Search at first in the reflog of the HEAD and the branches
...
I will implement the second bullet above soon. Stay tuned!
#!/opt/local/bin/perl
my $type = $ARGV[0]; # 'tree' or 'blob'?
my $pattern = $ARGV[1]; # filename to search for as regex
my $createBranches = $ARGV[2]; # 'y' if you want to create branches (only when search for 'tree')
##################################################################
# find all objects (blobs, trees, commits, tags) in .git/objects
##################################################################
my @AllFiles = `find .git/objects/`;
my @AllSha1 = ();
for my $object (@AllFiles) {
if($object =~ /([0-9a-f][0-9a-f])\/([0-9a-f]{38})/) {
my $sha1 = $1 . $2;
push(@AllSha1, $sha1);
}
}
##################################################################
# find all trees or blobs containing the pattern
##################################################################
my $ctr = 0;
for my $foundSha1 (@AllSha1) {
chomp $foundSha1;
my $t = `git cat-file -t $foundSha1`;
chomp $t;
if($t eq $type) {
my @Lines = `git cat-file -p $foundSha1`;
for my $line (@Lines) {
if($line =~ /$pattern/) {
$ctr++;
printf "found $type: %s\n", $foundSha1;
if($type eq 'tree' && $createBranches eq 'y') {
my $branchName = sprintf "found/%03s", $ctr;
printf "created branch: %s\n", $branchName;
`git commit-tree $foundSha1 -m "found $pattern" | xargs -I{} git branch $branchName {}`;
}
break;
}
}
}
}
Recently I tried to solve a problem regarding CDI.
Let me explain:
The Situation
There are interfaces extending a base interface:
public interface BaseInterface {
...
}
public interface InterfaceA extends BaseInterface {
...
}
public interface InterfaceB extends BaseInterface {
...
}
// and many more
public interface InterfaceX extends BaseInterface {
...
}
Now I want a CDI producer injecting proxies for any sub-interface of the BaseInterface
To let the producer find its @Injects I define a @Qualifier.
Something like this:
@Qualifier
public @interface ProxyProducer {
}
...
public class Consumer {
@Inject
@ProxyProducer
InterfaceA proxyForInterfaceA;
@Inject
@ProxyProducer
InterfaceB proxyForInterfaceB;
...
}
...
public class Producer {
@Produces
@ProxyProducer
BaseInterface produceProxy(InjectionPoint ip) {
Class> injectionPointClass = (Class>) ip.getType();
proxy = createDynamicProxy(injectionPointClass);
return proxy;
}
BaseInterface createDynamicProxy(Class> interfaceClass) {
// create and return dynamic proxy
}
}
The Problem
Too bad! It does not work.
Producer and consumer will not find each other.
Even the @ProxyProducer qualifier does not convince the CDI container to match producer and injection point.
Recently I lost a file in the Git orcus (aka './git/objects').
I knew it had been there some time ago.
But now it was gone and the Git on-board tools ('rev-list', 'fsck', 'reflog', ...) didn't help.
They showed a lot of dangling commits, trees and blobs but not the file I was searching for.
The Solution (maybe not the best)
I was doomed to dive into the .git/object-slough.
Based on a shell script on stackoverflow.com
from willkil
I created a small Perl script:
It has one command line argument: the file to search for (as a regex).
In the first phase it looks into each tree object and checks whether it contains the file.
In the second phase it looks into each commit object and checks whether it points to one of the tree objects found in phase 1.
At last it creates a branch ('found/0', 'found/1', ...) for each commit found in phase 2.
It does not look into packed objects.
Here is the script:
#!/opt/local/bin/perl
my $pattern = $ARGV[0]; # filename to search for as regex
##################################################################
# find all objects (blobs, trees, commits, tags) in .git/objects
##################################################################
my @AllFiles = `find .git/objects/`;
my @AllSha1 = ();
for my $object (@AllFiles) {
if($object =~ /([0-9a-f][0-9a-f])\/([0-9a-f]{38})/) {
my $sha1 = $1 . $2;
push(@AllSha1, $sha1);
}
}
##################################################################
# find all trees containing the file
##################################################################
my @FoundTrees = ();
for my $treeSha1 (@AllSha1) {
chomp $treeSha1;
my $type = `git cat-file -t $treeSha1`;
chomp $type;
if($type eq "tree") {
my @Lines = `git cat-file -p $treeSha1`;
for my $line (@Lines) {
if($line =~ /$pattern/) {
printf "found tree: %s\n", $treeSha1;
push(@FoundTrees, $treeSha1);
break;
}
}
}
}
##################################################################
# find all commits pointing to one of the trees found above
##################################################################
my @FoundCommits = ();
for my $commitSha1 (@AllSha1) {
chomp $commitSha1;
my $type = `git cat-file -t $commitSha1`;
chomp $type;
if($type eq "commit") {
my @Lines = `git cat-file -p $commitSha1`;
for my $line (@Lines) {
for my $foundTreeSha1 (@FoundTrees) {
if($line =~ /$foundTreeSha1/) {
printf "found commit: %s\n", $commitSha1;
push(@FoundCommits, $commitSha1);
break;
}
}
}
}
}
##################################################################
# create a branch for each commit found
##################################################################
my $i = 0;
for my $foundSha1 (@FoundCommits) {
my $branchName = "found/" . $i;
`git branch $branchName $foundSha1`;
printf "branch created: %s pointing to %s\n", $branchName, $foundSha1;
$i++;
}
Be aware! This script creates a branch for each commit to a tree with the file you're searching for. Could be some!!!
Possible improvement: Only create a branch for the most recent commit (or track the chain of commits and search for the head of it)