You have two general choices:

- Revert the revert commit (creating a second revert commit that takes you back to the original)
- Throw away the revert commit with 

&gt; git reset --hard HEAD^

The second option is only appropriate if you have *not* pushed your changes anywhere else. In fact, if you haven&#39;t pushed your first revert commit anywhere yet, you can simply use
 

&gt; git reset --hard

to roll back without creating any revert commits at all.

If you haven&#39;t done it completely, i.e., in `gitbash` you see something like:

    Username@Host MINGW64 /d/code/your-project (feature|REVERTING)

then you can use `git revert --abort` to abort.

If you have done it.. just don&#39;t reset, the changes are still there. Use `git reset` to change the state. Instead of `--hard`, you can also use `--soft`(keep all the changes). 

    git reset --soft HEAD^ // discard the last commit, keeping all the changes after that

Also, if you want to revert more than 1 commits:

    git reset --soft HEAD~3 // discart last 3 commits. Don&#39;t know if it works for commits of others.


As you create a new `commit` which `reverts another commit` you can treat it like a normal commit. 

So basically you have many choices, such as

&gt;  - `git rebase -i` (remove the revert commit)
&gt;  - `git reset --hard &lt;commitID&gt;` (reset to the commit before the revert, **you&#39;ll lose all local changes**)
&gt;  - `git reset --soft &lt;commitID&gt;` (same as above but keeps local changes)
&gt;  - technically you can use `git revert &lt;commitId&gt;` to revert your revert

 

How can I get list of all available classes in [`CLASSPATH`][1] at runtime?  
In Eclipse IDE, you can do this by pressing &lt;kbd&gt;Ctrl&lt;/kbd&gt;+&lt;kbd&gt;Shift&lt;/kbd&gt;+&lt;kbd&gt;T&lt;/kbd&gt;.  
Is there any method in Java to get it done?

  [1]: http://docs.oracle.com/javase/tutorial/essential/environment/paths.html &quot;ClassPath&quot;

Get all of the Classes in the Classpath

Microsoft introduced the [`IObservable&lt;T&gt;` interface](http://msdn.microsoft.com/en-us/library/dd990377.aspx &quot;MSDN reference page&quot;) to the BCL with .NET Framework 4, and I thought, &quot;Great, finally, I must use it!&quot; So I dug deep and read posts and documentation and even implemented the pattern.

After doing so I&#39;ve realized that the basic implementation actually sends all the `T` events to all of its subscribers without any filtering on it; i.e. plain broadcast. I read somewhere that the Observable pattern is meant for plain broadcast. I feel that this is not true and that I am missing something.

**My questions:**

1. If I add a filtering mechanism, what is the difference between using the Observable pattern and just using plain CLR events?

2. When should one use this pattern, and when should one choose to use plain CLR events?

3. What are the main advantages of the Observable pattern?

IObservable vs Plain Events or Why Should I use IObservable?

In git let say I commit A and B

    A---[B]

But then I revert with

    git revert HEAD

So I am there now:

    [A]---B

How do I cancel my revert so that I can go back to B?

Git cancel a revert

In git let say I commit A and B
<pre><code class="hljs language-css">A---[B]
</code></pre>
But then I revert with
<pre><code class="hljs">git revert HEAD
</code></pre>
So I am there now:
<pre><code class="hljs language-css">[A]---B
</code></pre>
How do I cancel my revert so that I can go back to B?

I have a gitignore file that makes git ignore `*.dll` files, and that is actually the behavior I want. However, if I want an exception ( i.e. to be able to commit `foo.dll`), how can I achieve this?

git ignore exception

I&#39;ve read a lot of different questions and answers on Stack Overflow as well as **git** documentation on how the **core.autocrlf** setting works.

This is my understanding from what I&#39;ve read:

Unix and Mac OSX (pre-OSX uses CR) clients use LF line endings.  
Windows clients use CRLF line endings.

When core.autocrlf is set to true on the client, the git repository always stores files in LF line ending format and line endings in files on the client are converted back and forth on check out / commit for clients (i.e. Windows) that use non-LF line endings, no matter what format the line endings files are on the client (this disagrees with Tim Clem&#39;s definition - see update below).

Here is a matrix that tries to document the same for the &#39;input&#39; and &#39;false&#39; settings of core.autocrlf with question marks where I&#39;m not sure of line ending conversion behavior.

My questions are:

 1. **What should the question marks be?**
 2. **Is this matrix correct for the &quot;non-question marks&quot;?**

I&#39;ll update the question marks from the answers as consensus appears to be formed.

&lt;pre&gt;
                       core.autocrlf value
            true            input              false
----------------------------------------------------------
commit   |  convert           ?                  ?
new      |  to LF      (convert to LF?)   (no conversion?)

commit   |  convert to        ?                 no 
existing |  LF         (convert to LF?)     conversion

checkout |  convert to        ?                 no
existing |  CRLF       (no conversion?)     conversion

&lt;/pre&gt;

I&#39;m not really looking for opinions on the pros and cons of the various settings.  I&#39;m just looking for data which makes it clear how to expect git to operate with each of the three settings.

--

**Update 04/17/2012**: After reading [the article by Tim Clem][1] linked by JJD in the comments, I have modified some of the values in the &quot;unknown&quot; values in the table above, as well as changing &quot;checkout existing | true to convert to CRLF instead of convert to client&quot;.  Here are the definitions he gives, which are more clear than anything I&#39;ve seen elsewhere:

**core.autocrlf = false**

&gt; This is the default, but most people are encouraged to change this
&gt; immediately. The result of using false is that Git doesn’t ever mess
&gt; with line endings on your file. You can check in files with LF or CRLF
&gt; or CR or some random mix of those three and Git does not care. This
&gt; can make diffs harder to read and merges more difficult. Most people
&gt; working in a Unix/Linux world use this value because they don’t have
&gt; CRLF problems and they don’t need Git to be doing extra work whenever
&gt; files are written to the object database or written out into the
&gt; working directory.

**core.autocrlf = true**

&gt; This means that Git will process all text files and make sure that
&gt; CRLF is replaced with LF when writing that file to the object database
&gt; and turn all LF back into CRLF when writing out into the working
&gt; directory. This is the recommended setting on Windows because it
&gt; ensures that your repository can be used on other platforms while
&gt; retaining CRLF in your working directory.

**core.autocrlf = input**

&gt; This means that Git will process all text files and make sure that
&gt; CRLF is replaced with LF when writing that file to the object
&gt; database. It will not, however, do the reverse. When you read files
&gt; back out of the object database and write them into the working
&gt; directory they will still have LFs to denote the end of line. This
&gt; setting is generally used on Unix/Linux/OS X to prevent CRLFs from
&gt; getting written into the repository. The idea being that if you pasted
&gt; code from a web browser and accidentally got CRLFs into one of your
&gt; files, Git would make sure they were replaced with LFs when you wrote
&gt; to the object database.


Tim&#39;s article is excellent, the only thing I can think of that is missing is that he assumes the repository is in LF format, which is not necessarily true, especially for Windows only projects.

Comparing Tim&#39;s article to the highest voted [answer](https://stackoverflow.com/a/4425433/147511) to date by jmlane shows perfect agreement on the true and input settings and disagreement on the false setting.


  [1]: https://adaptivepatchwork.com/2012/03/01/mind-the-end-of-your-line/

How line ending conversions work with git core.autocrlf between different operating systems

I merged branch `dog` into `animal`.  When I go to commit, I get the following:

    Unmerged paths:
    (use &quot;git reset HEAD &lt;file&gt;...&quot; to unstage)
    (use &quot;git add &lt;file&gt;...&quot; to mark resolution
    both deleted:       ../public/images/originals/dog.ai
    added by them:      ../public/images/original_files/dog.ai

I had different directory names and file names in each branch.  The `animal` branch has the changes that I want.

When I go to reset the head, it doesn&#39;t work.  And when I go to take any other git action (remove, checkout, etc), I get a `path not found` error.

What commands do I need to execute to resolve this?





How to resolve git status &quot;Unmerged paths:&quot;?

I want to version control my web server as described in  https://stackoverflow.com/questions/3154227/version-control-for-my-web-server, by creating a git repo out of my `/var/www directory`.  My hope was that I would then be able to push web content from our dev server to github, pull it to our production server, and spend the rest of the day at the pool.  

Apparently a kink in my plan is that Git won&#39;t respect file permissions (I haven&#39;t tried it, only reading about it now.)  I guess this makes sense in that different boxes are liable to have different user/group setups.  But if I wanted to force permissions to propagate, knowing my servers are configured the same, do I have any options? Or is there an easier way to approach what I&#39;m trying to do?

Retaining file permissions with Git

I would like to do a diff between two tags and committed changes between those two tags. Could you please tell me the command?

How to compare two tags with git?

When using Mercurial, how do you undo all changes in the working directory since the last commit? It seems like this would be a simple thing, but it&#39;s escaping me.

For example, let&#39;s say I have 4 commits. Then, I make some changes to my code. Then I decide that my changes are bad and I just want to go back to the state of the code at my last commit. So, I think I should do:

    hg update 4

with 4 being the revision # of my latest commit. But, Mercurial doesn&#39;t change any of the files in my working directory. Why not?

Mercurial: How do you undo changes?

Is there something like &quot;git show tags&quot;?

How to see all tags in a git repository in command line

I am new to autotools and I am working on a C project. I want to add my project to a git repository. Which files generated by the autotools I need to track in my version control system and which should be ignored?

Which files generated by Autotools should I keep in version control repository?

I don&#39;t want to end up with [82 feature branches hanging around](https://stackoverflow.com/questions/2353804/list-git-branches-that-can-safely-be-deleted), so I&#39;m wondering what the potential drawbacks are to simply deleting the feature branch as soon as I merge it to master.

Workflow:

    git co -b feat-xyz
    hack hack
    git ci
    hack some more
    git ci
    git co master
    git merge feat-xyz
    smoke test
    git br -d feat-xyz

Any issues here?

When is the right time to delete a git feature branch?

I&#39;m looking to split a commit up and not sure which reset option to use.

I was looking at the page https://stackoverflow.com/questions/2530060/can-you-explain-to-me-git-reset-in-plain-english, but I realized I don&#39;t really understand what the git index or staging area is and thus the explanations didn&#39;t help.

Also, the use cases for `--mixed` and `--soft` look the same to me in that answer (when you want to fix and recommit). Can someone break it down even more?  I realize `--mixed` is probably the option to go with, but I want to know *why*. Lastly, what about `--hard`?

Can someone give me a workflow example of how selecting the 3 options would happen?


Content Type	Original Author	Original Content on Stackoverflow
Question	mathk	View Question on Stackoverflow
Solution 1 - Git	Greg Hewgill	View Answer on Stackoverflow
Solution 2 - Git	WesternGun	View Answer on Stackoverflow
Solution 3 - Git	elp	View Answer on Stackoverflow

Git cancel a revert

Git Problem Overview

Git Solutions

Solution 1 - Git

Solution 2 - Git

Solution 3 - Git

IObservable vs Plain Events or Why Should I use IObservable?

Get all of the Classes in the Classpath

Attributions