Merge branch 'fix-map-skipped-keys' of https://github.com/undead-lewis/msgpack-cli into 0.5

Author: yfakariya

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/AbstractSerializers/SerializerBuilder`3.Object.cs

@@ -440,6 +440,11 @@ private IEnumerable<TConstruct> EmitObjectUnpackFromMapCore( TContext context, T
 							this.EmitStringSwitchStatement(
 								context,
 								key,
+								this.EmitInvokeVoidMethod(
+									context,
+									context.Unpacker,
+									typeof( Unpacker ).GetMethod( "Skip" )
+								),
 								entries.Where( e => e.Member != null ).ToDictionary(
 									entry => entry.Contract.Name,
 									entry =>

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 )
 		{

src/MsgPack/Serialization/ReflectionSerializers/ReflectionObjectMessagePackSerializer`1.cs

@@ -157,7 +157,18 @@ protected internal override T UnpackFromCore( Unpacker unpacker )
 						continue;
 					}
 
-					result = this.UnpackMemberValue( result, unpacker, itemsCount, ref unpacked, this._memberIndexes[ name ], i );
+					int index;
+					if ( !this._memberIndexes.TryGetValue(name, out index) )
+					{
+						// key does not exist in the object, skip the associated value
+						if ( unpacker.Skip() == null )
+						{
+							throw SerializationExceptions.NewMissingItem( i );
+						}
+						continue;
+					}
+
+					result = this.UnpackMemberValue(result, unpacker, itemsCount, ref unpacked, index, i);
 				}
 			}
 

test/MsgPack.UnitTest/Serialization/VersioningTest.cs

@@ -64,9 +64,11 @@ private static void TestExtraFieldCore<T>( SerializationMethod method, EmitterFl
 				else
 				{
 					var packer = Packer.Create( stream, false );
-					packer.PackMapHeader( 4 );
+					packer.PackMapHeader( 5 );
 					packer.Pack( "Field1" );
 					packer.Pack( 1 );
+					packer.Pack( "Extra" );
+					packer.PackNull();
 					packer.Pack( "Field2" );
 					packer.Pack( -1 );
 					packer.Pack( "Field3" );