Fix submodules

2 files changed, 0 insertions, 470 deletions

diff --git a/vim/bundle/vim-snippets b/vim/bundle/vim-snippets
new file mode 160000
+Subproject 15d7e5ec26ec93adee4051b6359be90a943aa38
diff --git a/vim/bundle/vim-snippets/snippets/cs.snippets b/vim/bundle/vim-snippets/snippets/cs.snippets
deleted file mode 100644
index 40e9c8f..0000000
--- a/vim/bundle/vim-snippets/snippets/cs.snippets
+++ /dev/null
@@ -1,470 +0,0 @@
-# cs.snippets
-# ===========
-#
-# Standard C-Sharp snippets for snipmate.
-#
-# Largely ported over from Visual Studio 2010 snippets plus
-# a few snippets from Resharper plus a few widely known snippets.
-#
-# Most snippets on elements (i.e. classes, properties)
-# follow suffix conventions. The order of suffixes to a snippet
-# is fixed.
-#
-# Snippet Suffix Order
-# --------------------
-# 1. Access Modifiers
-# 2. Class Modifiers
-#
-# Access Modifier Suffix Table
-# ----------------------------
-# + = public
-# & = internal
-# | = protected
-# - = private
-#
-# Example: `cls&` expands to `internal class $1`.
-# Access modifiers might be doubled to indicate
-# different modifiers for get/set on properties.
-# Example: `pb+-` expands to `public bool $1 { get; private set; }`
-#
-# Class Modifier Table
-# --------------------
-# ^ = static
-# % = abstract
-#
-# Example: `cls|%` expands to `protected abstract class $1`
-#
-# On method and property snippets, you can directly set
-# one of the common types int, string and bool, if desired,
-# just by appending the type modifier.
-#
-# Type Modifier Table
-# -------------------
-# i = integer
-# s = string
-# b = bool
-#
-# Example: `pi+&` expands to `public int $1 { get; internal set; }`
-#
-# I'll most propably add more stuff in here like
-# * List/Array constructio
-# * Mostly used generics
-# * Linq
-# * Funcs, Actions, Predicates
-# * Lambda
-# * Events
-#
-# Feedback is welcome!
-#
-# Main 
-snippet sim
-	${1:public }static int Main(string[] args) {
-		${0}
-		return 0;
-	}
-snippet simc
-	public class Application {
-		${1:public }static int Main(string[] args) {
-			${0}
-			return 0;
-		}
-	}
-snippet svm
-	${1:public }static void Main(string[] args) {
-		${0}
-	}
-# if condition
-snippet if
-	if (${1:true}) {
-		${0}
-	}
-snippet el
-	else {
-		${0}
-	}
-snippet ifs
-	if (${1})
-		${0}
-# ternary conditional
-snippet t
-	${1} ? ${2} : ${0}
-snippet ?
-	${1} ? ${2} : ${0}
-# do while loop
-snippet do
-	do {
-		${0}
-	} while (${1:true});
-# while loop
-snippet wh
-	while (${1:true}) {
-		${0}
-	}
-# for loop
-snippet for
-	for (int ${1:i} = 0; $1 < ${2:count}; $1${3:++}) {
-		${0}
-	}
-snippet forr
-	for (int ${1:i} = ${2:length}; $1 >= 0; $1--) {
-		${0}
-	}
-# foreach
-snippet fore
-	foreach (${1:var} ${2:entry} in ${3}) {
-		${0}
-	}
-snippet foreach
-	foreach (${1:var} ${2:entry} in ${3}) {
-		${0}
-	}
-snippet each
-	foreach (${1:var} ${2:entry} in ${3}) {
-		${0}
-	}
-# interfaces
-snippet interface
-	public interface ${1:`vim_snippets#Filename()`} {
-		${0}
-	}
-snippet if+
-	public interface ${1:`vim_snippets#Filename()`} {
-		${0}
-	}
-# class bodies
-snippet class
-	public class ${1:`vim_snippets#Filename()`} {
-		${0}
-	}
-snippet cls
-	${2:public} class ${1:`vim_snippets#Filename()`} {
-		${0}
-	}
-snippet cls+
-	public class ${1:`vim_snippets#Filename()`} {
-		${0}
-	}
-snippet cls+^
-	public static class ${1:`vim_snippets#Filename()`} {
-		${0}
-	}
-snippet cls&
-	internal class ${1:`vim_snippets#Filename()`} {
-		${0}
-	}
-snippet cls&^
-	internal static class ${1:`vim_snippets#Filename()`} {
-		${0}
-	}
-snippet cls|
-	protected class ${1:`vim_snippets#Filename()`} {
-		${0}
-	}
-snippet cls|%
-	protected abstract class ${1:`vim_snippets#Filename()`} {
-		${0}
-	}
-# constructor
-snippet ctor
-	public ${1:`vim_snippets#Filename()`}() {
-		${0}
-	}
-# properties - auto properties by default.
-# default type is int with layout get / set.
-snippet prop
-	${1:public} ${2:int} ${3} { get; set; }
-snippet p
-	${1:public} ${2:int} ${3} { get; set; }
-snippet p+
-	public ${1:int} ${2} { get; set; }
-snippet p+&
-	public ${1:int} ${2} { get; internal set; }
-snippet p+|
-	public ${1:int} ${2} { get; protected set; }
-snippet p+-
-	public ${1:int} ${2} { get; private set; }
-snippet p&
-	internal ${1:int} ${2} { get; set; }
-snippet p&|
-	internal ${1:int} ${2} { get; protected set; }
-snippet p&-
-	internal ${1:int} ${2} { get; private set; }
-snippet p|
-	protected ${1:int} ${2} { get; set; }
-snippet p|-
-	protected ${1:int} ${2} { get; private set; }
-snippet p-
-	private ${1:int} ${2} { get; set; }
-# property - bool
-snippet pi
-	${1:public} int ${2} { get; set; }
-snippet pi+
-	public int ${1} { get; set; }
-snippet pi+&
-	public int ${1} { get; internal set; }
-snippet pi+|
-	public int ${1} { get; protected set; }
-snippet pi+-
-	public int ${1} { get; private set; }
-snippet pi&
-	internal int ${1} { get; set; }
-snippet pi&|
-	internal int ${1} { get; protected set; }
-snippet pi&-
-	internal int ${1} { get; private set; }
-snippet pi|
-	protected int ${1} { get; set; }
-snippet pi|-
-	protected int ${1} { get; private set; }
-snippet pi-
-	private int ${1} { get; set; }
-# property - bool
-snippet pb
-	${1:public} bool ${2} { get; set; }
-snippet pb+
-	public bool ${1} { get; set; }
-snippet pb+&
-	public bool ${1} { get; internal set; }
-snippet pb+|
-	public bool ${1} { get; protected set; }
-snippet pb+-
-	public bool ${1} { get; private set; }
-snippet pb&
-	internal bool ${1} { get; set; }
-snippet pb&|
-	internal bool ${1} { get; protected set; }
-snippet pb&-
-	internal bool ${1} { get; private set; }
-snippet pb|
-	protected bool ${1} { get; set; }
-snippet pb|-
-	protected bool ${1} { get; private set; }
-snippet pb-
-	private bool ${1} { get; set; }
-# property - string
-snippet ps
-	${1:public} string ${2} { get; set; }
-snippet ps+
-	public string ${1} { get; set; }
-snippet ps+&
-	public string ${1} { get; internal set; }
-snippet ps+|
-	public string ${1} { get; protected set; }
-snippet ps+-
-	public string ${1} { get; private set; }
-snippet ps&
-	internal string ${1} { get; set; }
-snippet ps&|
-	internal string ${1} { get; protected set; }
-snippet ps&-
-	internal string ${1} { get; private set; }
-snippet ps|
-	protected string ${1} { get; set; }
-snippet ps|-
-	protected string ${1} { get; private set; }
-snippet ps-
-	private string ${1} { get; set; }
-# members - void
-snippet m
-	${1:public} ${2:void} ${3}(${4}) {
-		${0}
-	}
-snippet m+
-	public ${1:void} ${2}(${3}) {
-		${0}
-	}
-snippet m&
-	internal ${1:void} ${2}(${3}) {
-		${0}
-	}
-snippet m|
-	protected ${1:void} ${2}(${3}) {
-		${0}
-	}
-snippet m-
-	private ${1:void} ${2}(${3}) {
-		${0}
-	}
-# members - int
-snippet mi
-	${1:public} int ${2}(${3}) {
-		${0:return 0;}
-	}
-snippet mi+
-	public int ${1}(${2}) {
-		${0:return 0;}
-	}
-snippet mi&
-	internal int ${1}(${2}) {
-		${0:return 0;}
-	}
-snippet mi|
-	protected int ${1}(${2}) {
-		${0:return 0;}
-	}
-snippet mi-
-	private int ${1}(${2}) {
-		${0:return 0;}
-	}
-# members - bool
-snippet mb
-	${1:public} bool ${2}(${3}) {
-		${0:return false;}
-	}
-snippet mb+
-	public bool ${1}(${2}) {
-		${0:return false;}
-	}
-snippet mb&
-	internal bool ${1}(${2}) {
-		${0:return false;}
-	}
-snippet mb|
-	protected bool ${1}(${2}) {
-		${0:return false;}
-	}
-snippet mb-
-	private bool ${1}(${2}) {
-		${0:return false;}
-	}
-# members - string
-snippet ms
-	${1:public} string ${2}(${3}) {
-		${0:return "";}
-	}
-snippet ms+
-	public string ${1}(${2}) {
-		${0:return "";}
-	}
-snippet ms&
-	internal string ${1}(${2}) {
-		${0:return "";}
-	}
-snippet ms|
-	protected string ${1:}(${2:}) {
-		${0:return "";}
-	}
-snippet ms-
-	private string ${1}(${2}) {
-		${0:return "";}
-	}
-# structure
-snippet struct
-	public struct ${1:`vim_snippets#Filename()`} {
-		${0}
-	}
-# enumeration
-snippet enum
-	enum ${1} {
-		${0}
-	}
-	
-snippet enum+
-	public enum ${1} {
-		${0}
-	}
-# preprocessor directives
-snippet #if
-	#if
-		${0}
-	#endif
-# inline xml documentation
-snippet ///
-	/// <summary>
-	/// ${0}
-	/// </summary>
-snippet <p
-	<param name="${1}">${2:$1}</param>
-snippet <ex
-	<exception cref="${1:System.Exception}">${2}</exception>
-snippet <r
-	<returns>${1}</returns>{
-snippet <s
-	<see cref="${1}"/>
-snippet <rem
-	<remarks>${1}</remarks>
-snippet <c
-	<code>${1}</code>
-
-snippet cw
-	Console.WriteLine(${1});
-
-# equals override
-snippet eq
-	public override bool Equals(object obj) {
-		if (obj == null || GetType() != obj.GetType()) {
-			return false;
-		}
-		${0:throw new NotImplementedException();}
-		return base.Equals(obj);
-	}
-# exception 
-snippet exc
-	public class ${1:MyException} : ${2:Exception} {
-		public $1() { }
-		public $1(string message) : base(message) { }
-		public $1(string message, Exception inner) : base(message, inner) { }
-		protected $1(
-			System.Runtime.Serialization.SerializationInfo info,
-			System.Runtime.Serialization.StreamingContext context)
-				: base(info, context) { }
-	}
-# indexer 
-snippet index
-	public ${1:object} this[${2:int} index] {
-		get { ${0} }
-		set { ${0} }
-	}
-# eventhandler 
-snippet inv
-	EventHandler temp = ${1:MyEvent};
-	if (${2:temp} != null) {
-		$2();
-	}
-# lock
-snippet lock
-	lock (${1:this}) {
-		${0}
-	}
-# namespace
-snippet namespace
-	namespace ${1:MyNamespace} {
-		${0}
-	}
-# property
-snippet prop
-	public ${1:int} ${2:MyProperty} { get; set; }
-snippet propf
-	private ${1:int} ${2:myVar};
-		public $1 ${3:MyProperty} {
-			get { return $2; }
-			set { $2 = value; }
-		}
-snippet propg
-	public ${1:int} ${2:MyProperty} { get; private set; }
-# switch    
-snippet switch
-	switch (${1:switch_on}) {
-		${0}
-		default:
-	}
-# try
-snippet try
-	try {
-			${0}
-	}
-	catch (${1:System.Exception}) {
-			throw;
-	}
-snippet tryf
-	try {
-		${0}
-	}
-	finally {
-		${1}
-	}
-# using
-snippet usi
-	using(${1:resource}) {
-		${0}
-	}