expose and implement switch statemetns with default case

Author: Lewis Mohr

src/MsgPack/Serialization/AbstractSerializers/SerializerBuilderContract`3.cs

@@ -462,6 +462,17 @@ protected override TConstruct EmitStringSwitchStatement( TContext context, TCons
 			return default( TConstruct );
 		}
 
+		protected override TConstruct EmitStringSwitchStatement (TContext context, TConstruct target, TConstruct defaultCase, IDictionary<string, TConstruct> cases) {
+			Contract.Requires(context != null);
+			Contract.Requires(target != null);
+			Contract.Requires(defaultCase != null);
+			Contract.Requires(cases != null);
+			Contract.Requires(cases.Count > 0);
+			Contract.Ensures(Contract.Result<TConstruct>() != null);
+			Contract.Ensures(Contract.Result<TConstruct>().ContextType == typeof(void));
+			return default(TConstruct);
+		}
+
 		protected override TConstruct EmitForLoop( TContext context, TConstruct count, Func<ForLoopContext, TConstruct> loopBodyEmitter )
 		{
 			Contract.Requires( context != null );

src/MsgPack/Serialization/AbstractSerializers/SerializerBuilder`3.CommonConstructs.cs

@@ -1298,6 +1298,18 @@ protected abstract TConstruct EmitStringSwitchStatement(
 			TContext context, TConstruct target, IDictionary<string, TConstruct> cases
 		);
 
+		/// <summary>
+		///		Emits string switch statement.
+		/// </summary>
+		/// <param name="context">The generation context.</param>
+		/// <param name="target">Target string expression.</param>
+		/// <param name="defaultCase">Default case expression.</param>
+		/// <param name="cases">The case statements. The keys are case condition, and values are actual statement.</param>
+		/// <returns>The switch statement.</returns>
+		protected abstract TConstruct EmitStringSwitchStatement (
+			TContext context, TConstruct target, TConstruct defaultCase, IDictionary<string, TConstruct> cases
+		);
+
 		/// <summary>
 		/// 	Emits the return statement
 		/// </summary>

src/MsgPack/Serialization/CodeDomSerializers/CodeDomSerializerBuilder`1.cs

@@ -670,6 +670,30 @@ protected override CodeDomConstruct EmitStringSwitchStatement( CodeDomContext co
 				);
 		}
 
+		protected override CodeDomConstruct EmitStringSwitchStatement (CodeDomContext context, CodeDomConstruct target, CodeDomConstruct defaultCase, IDictionary<string, CodeDomConstruct> cases) {
+#if DEBUG
+			Contract.Assert(target.IsExpression);
+			Contract.Assert(defaultCase.IsStatement);
+			Contract.Assert(cases.Values.All(c => c.IsStatement));
+#endif
+
+			var statements = cases.Aggregate<KeyValuePair<string, CodeDomConstruct>, CodeConditionStatement>(
+				null,
+				(current, caseStatement) =>
+				new CodeConditionStatement(
+					new CodeBinaryOperatorExpression(
+						target.AsExpression(),
+						CodeBinaryOperatorType.ValueEquality,
+						new CodePrimitiveExpression(caseStatement.Key)
+					),
+					caseStatement.Value.AsStatements().ToArray(),
+					current == null ? defaultCase.AsStatements().ToArray() : new CodeStatement[] { current }
+				)
+			);
+
+			return CodeDomConstruct.Statement(statements);
+		}
+
 		[System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "1", Justification = "Asserted internally" )]
 		protected override CodeDomConstruct EmitRetrunStatement( CodeDomContext context, CodeDomConstruct expression )
 		{

src/MsgPack/Serialization/EmittingSerializers/ILEmittingSerializerBuilder`2.cs

@@ -701,6 +701,29 @@ protected override ILConstruct EmitStringSwitchStatement( TContext context, ILCo
 			return @else;
 		}
 
+		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "2", Justification = "Asserted internally")]
+		protected override ILConstruct EmitStringSwitchStatement (TContext context, ILConstruct target, ILConstruct defaultCase, IDictionary<string, ILConstruct> cases) {
+			// Simple if statements
+			ILConstruct @else = defaultCase;
+			foreach (var @case in cases) {
+				@else =
+					this.EmitConditionalExpression(
+						context,
+						this.EmitInvokeMethodExpression(
+							context,
+							null,
+							Metadata._String.op_Equality,
+							target,
+							this.MakeStringLiteral(context, @case.Key)
+						),
+						@case.Value,
+						@else
+					);
+			}
+
+			return @else;
+		}
+
 		protected override ILConstruct EmitForLoop( TContext context, ILConstruct count, Func<ForLoopContext, ILConstruct> loopBodyEmitter )
 		{
 			var i =

src/MsgPack/Serialization/ExpressionSerializers/ExpressionTreeSerializerBuilder`1.cs

@@ -481,6 +481,19 @@ protected override ExpressionConstruct EmitStringSwitchStatement(
 				);
 		}
 
+		protected override ExpressionConstruct EmitStringSwitchStatement (
+			ExpressionTreeContext context, ExpressionConstruct target, ExpressionConstruct defaultCase, IDictionary<string, ExpressionConstruct> cases
+		) {
+			return
+				Expression.Switch(
+					typeof(void),
+					target,
+					defaultCase,
+					Metadata._String.op_Equality,
+					cases.Select(kv => Expression.SwitchCase(kv.Value, Expression.Constant(kv.Key))).ToArray()
+				);
+		}
+
 		[System.Diagnostics.CodeAnalysis.SuppressMessage( "Microsoft.Design", "CA1062:ValidateArgumentsOfPublicMethods", MessageId = "2", Justification = "Asserted internally" )]
 		protected override ExpressionConstruct EmitForLoop( ExpressionTreeContext context, ExpressionConstruct count, Func<ForLoopContext, ExpressionConstruct> loopBodyEmitter )
 		{