public LayoutInfo ConvertStringToLayoutInfo(string layoutInfo, Store store)
        {
            LayoutInfo lInfo = null;

            Microsoft.VisualStudio.Modeling.SerializationResult serializationResult = new Microsoft.VisualStudio.Modeling.SerializationResult();
            DomainXmlSerializerDirectory directory = this.GetDirectory(store);
            System.Text.Encoding encoding = System.Text.Encoding.GetEncoding("ISO-8859-1");
            Microsoft.VisualStudio.Modeling.SerializationContext serializationContext = new SerializationContext(directory, "", serializationResult);
            this.InitializeSerializationContext(store.DefaultPartition, serializationContext, false);

            DomainClassXmlSerializer rootSerializer = directory.GetSerializer(LayoutInfo.DomainClassId);
            using(System.Xml.XmlReader reader = System.Xml.XmlReader.Create(new System.IO.StringReader(layoutInfo)) )
            {
                
                reader.Read(); // Move to the first node - will be the XmlDeclaration if there is one.
                serializationResult.Encoding = encoding;

                reader.MoveToContent();

                lInfo = rootSerializer.TryCreateInstance(serializationContext, reader, store.DefaultPartition) as LayoutInfo;
                rootSerializer.Read(serializationContext, lInfo, reader);
            }

            return lInfo;
        }

		/// <summary>
		///		Determines <see cref="EnumSerializationMethod"/> for the target.
		/// </summary>
		/// <param name="context">Context information.</param>
		/// <param name="enumType">The target enum type.</param>
		/// <param name="enumMemberSerializationMethod">The method argued by the member.</param>
		/// <returns>Determined <see cref="EnumSerializationMethod"/> for the target.</returns>
		public static EnumSerializationMethod DetermineEnumSerializationMethod(
			SerializationContext context,
			Type enumType,
			EnumMemberSerializationMethod enumMemberSerializationMethod )
		{
			EnumSerializationMethod method = context.EnumSerializationMethod;
			switch ( enumMemberSerializationMethod )
			{
				case EnumMemberSerializationMethod.ByName:
				{
					method = EnumSerializationMethod.ByName;
					break;
				}
				case EnumMemberSerializationMethod.ByUnderlyingValue:
				{
					method = EnumSerializationMethod.ByUnderlyingValue;
					break;
				}
				default:
				{
					var attributesOnType = enumType.GetCustomAttributes( typeof( MessagePackEnumAttribute ), false );
					if ( attributesOnType.Length > 0 )
					{
						// ReSharper disable once PossibleNullReferenceException
						method = ( attributesOnType[ 0 ] as MessagePackEnumAttribute ).SerializationMethod;
					}

					break;
				}
			}

			return method;
		}

 public object Deserialize(
     StreamReader streamReader, 
     SerializationContext serializationContext, 
     PropertyMetaData propertyMetaData = null)
 {
     return streamReader.ReadInt16();
 }

        internal static int Serialize(Guid value, SerializationContext context, bool lengthPrefix)
        {
            if (value == Guid.Empty)
            {
                if (lengthPrefix)
                {
                    context.WriteByte(0);
                    return 1;
                }
                return 0;
            }
            byte[] buffer = value.ToByteArray();

            int len = 0;
            if (lengthPrefix)
            {
                context.WriteByte((byte)18);
                len = 1;
            }
            context.WriteByte(FieldLo << 3 | (int)WireType.Fixed64);
            context.WriteBlock(buffer, 0, 8);
            context.WriteByte(FieldHi << 3 | (int)WireType.Fixed64);
            context.WriteBlock(buffer, 8, 8);
            return len + 18;
        }

        public object Deserialize(
            StreamReader streamReader,
            SerializationContext serializationContext,
            PropertyMetaData propertyMetaData = null)
        {
            var mess = new GenericCmdMessage();
            mess.N3MessageType = (N3MessageType)streamReader.ReadInt32();
            mess.Identity = streamReader.ReadIdentity();
            mess.Unknown = streamReader.ReadByte();
            mess.Temp1 = streamReader.ReadInt32();
            mess.Count = streamReader.ReadInt32();
            mess.Action = (GenericCmdAction)streamReader.ReadInt32();
            mess.Temp4 = streamReader.ReadInt32();
            mess.User = streamReader.ReadIdentity();
            int len = 1;
            if (mess.Action == GenericCmdAction.UseItemOnItem)
            {
                len = 2;
            }

            mess.Target = new Identity[len];
            for (int i = 0; i < mess.Target.Length; i++)
            {
                mess.Target[i] = streamReader.ReadIdentity();
            }
            return mess;
        }

        private static void WritePropertiesAsElements(SerializationContext serializationContext, MetaModelLibrary element, global::System.Xml.XmlWriter writer)
        {
            // FilePath
            if (!serializationContext.Result.Failed)
            {
                global::System.String propValue = element.FilePath;
                if (!serializationContext.Result.Failed)
                {
                    if (!string.IsNullOrEmpty(propValue))
                        LanguageDSLSerializationHelper.Instance.WriteElementString(serializationContext, element, writer, "filePath", propValue);

                }
            }
            // Name
            if (!serializationContext.Result.Failed)
            {
                global::System.String propValue = element.Name;
                if (!serializationContext.Result.Failed)
                {
                    if (!string.IsNullOrEmpty(propValue))
                        LanguageDSLSerializationHelper.Instance.WriteElementString(serializationContext, element, writer, "name", propValue);

                }
            }
        }

 public object Deserialize(
     StreamReader streamReader, 
     SerializationContext serializationContext, 
     PropertyMetaData propertyMetaData = null)
 {
     return this.serializer.Deserialize(streamReader, serializationContext, propertyMetaData);
 }

        public object Deserialize(
            StreamReader streamReader, 
            SerializationContext serializationContext, 
            PropertyMetaData propertyMetaData = null)
        {
            var identityType = (IdentityType)streamReader.ReadInt32();
            if (identityType != IdentityType.VendingMachine)
            {
                streamReader.Position = streamReader.Position - 4;
                return null;
            }

            var playfieldVendorInfo = new PlayfieldVendorInfo
                                          {
                                              Unknown1 =
                                                  new Identity
                                                      {
                                                          Type = identityType, 
                                                          Instance = streamReader.ReadInt32()
                                                      }, 
                                              Unknown2 = streamReader.ReadInt32(), 
                                              VendorCount = streamReader.ReadInt32(), 
                                              FirstVendorId = streamReader.ReadInt32()
                                          };
            return playfieldVendorInfo;
        }

        public override void Serialize(SerializationContext context)
        {
            base.Serialize(context);

            int target = (Owner != null) ? Owner.ServerIndex : -1;
            context.Write(target);
        }

        public void ExportSolution()
        {
            DDay.iCal.iCalendar iCal = new DDay.iCal.iCalendar();
            var t = new DBManager();
            t.initInputData();
            t.initOutputData();
            foreach(ScheduledTimeSlot[] solution in (t.solutions))
            {
                for (int i = 0; i < solution.Length; i++)
                {
                    Event evt = iCal.Create<Event>();

                    evt.Start = iCalDateTime.Today.AddHours((int)solution[i].timeSlot.StartHour).AddDays((int)(solution[i].timeSlot.Day));

                    evt.End = iCalDateTime.Today.AddHours((int)solution[i].timeSlot.EndHour).AddDays((int)(solution[i].timeSlot.Day));

                    evt.Summary = string.Join(", ", solution[i].groups.Select(g => g.name));

                    evt.Location = solution[i].room.nameOrNumber;
                }
                break;
            }

            ISerializationContext ctx = new SerializationContext();
            ISerializerFactory factory = new DDay.iCal.Serialization.iCalendar.SerializerFactory();
            // Get a serializer for our object
            IStringSerializer serializer = factory.Build(iCal.GetType(), ctx) as IStringSerializer;

            string output = serializer.SerializeToString(iCal);
            var bytes = Encoding.UTF8.GetBytes(output);

            File.WriteAllBytes("solution.ics", bytes);
        }

        // GET: Calendar
        public ActionResult Index()
        {
            foreach (var r in Request.Params.AllKeys)
            {
                System.Diagnostics.Debug.WriteLine(r + " = " + Request.Params[r]);
            }

            var iCal = new iCalendar();

            Event evt = iCal.Create<Event>();
            evt.Start = iCalDateTime.Today.AddHours(8);
            evt.End = evt.Start.AddHours(18); // This also sets the duration
            evt.Description = "The event description";
            evt.Location = "Event location";
            evt.Summary = "18 hour event summary";
            
            evt = iCal.Create<Event>();
            evt.Start = iCalDateTime.Today.AddDays(5);
            evt.End = evt.Start.AddDays(1);
            evt.IsAllDay = true;
            evt.Summary = "All-day event";

            ISerializationContext ctx = new SerializationContext();
            ISerializerFactory factory = new DDay.iCal.Serialization.iCalendar.SerializerFactory();
            IStringSerializer serializer = factory.Build(iCal.GetType(), ctx) as IStringSerializer;

            string output = serializer.SerializeToString(iCal);
            var bytes = System.Text.Encoding.UTF8.GetBytes(output);

            return File(bytes, "text/calendar");
        }

		/// <summary>
		///		Initializes a new instance of the <see cref="DynamicMethodEmittingContext"/> class.
		/// </summary>
		/// <param name="context">The serialization context.</param>
		/// <param name="targetType">Type of the serialization target.</param>
		/// <param name="emitterFactory">
		///		The factory for <see cref="SerializerEmitter"/> to be used.
		/// </param>
		/// <param name="enumEmitterFactory">
		///		The factory for <see cref="EnumSerializerEmitter"/> to be used.
		/// </param>
		public DynamicMethodEmittingContext( SerializationContext context, Type targetType,
			Func<SerializerEmitter> emitterFactory, Func<EnumSerializerEmitter> enumEmitterFactory )
			: base( context, emitterFactory, enumEmitterFactory )
		{
			this._context = ILConstruct.Argument( 0, typeof( SerializationContext ), "context" );
			this.Reset( targetType, null );
		}

        public ByteArray(byte[] buffer, SerializationContext serializationContext)
        {
            this.serializationContext = serializationContext;

            memoryStream = new MemoryStream(buffer);
            ReloadStreams();
        }

        public override void GetObjectData(SerializationContext output)
        {
            base.GetObjectData(output);

            output.WriteVersion(1);
            output.Write(ROM);
        }

 public void SaveToFile(string icsFilename) {
     var ctx = new SerializationContext();
     var factory = new SerializerFactory();
     var serializer = factory.Build(ical.GetType(), ctx) as IStringSerializer;
     var content = serializer.SerializeToString(ical);
     File.WriteAllText(icsFilename, content);
 }

 public object ConvertTo(object item, Type sourceType, SerializationContext serializationContext)
 {
     // create a temp copy for processing
     List<IJsonTypeConverter> clonedList = new List<IJsonTypeConverter>(_converters);
     // loop through list until the last item, determining the source type along the way
     // process the last converter in the list and then remove it
     // repeat until all converters have been processed
     while (clonedList.Count > 0)
     {
         Type tempType = sourceType;
         for (int i = 0; i < clonedList.Count; i++)
         {
             if (i == clonedList.Count - 1)
             {
                 // last element, process
                 item = clonedList[i].ConvertTo(item, tempType, serializationContext);
             }
             else
             {
                 // just determine the source type
                 tempType = clonedList[i].GetSerializedType(tempType);
             }
         }
         clonedList.RemoveAt(clonedList.Count - 1);
     }
     return item;
 }

        public static int SerializeDecimal(decimal value, SerializationContext context, bool lengthPrefixed)
        {
            int[] bits = decimal.GetBits(value);
            ulong a = ((ulong)bits[1]) << 32, b = ((ulong)bits[0]) & 0xFFFFFFFFL;
            ulong low = a | b;
            uint high = (uint) bits[2];
            uint signScale = (uint)(((bits[3] >> 15) & 0x01FE) | ((bits[3] >> 31) & 0x0001));

            int len = 0;
            if (lengthPrefixed)
            {
                if (low != 0) len += 1 + SerializationContext.GetLength((long)low);
                if (high != 0) len += 1 + SerializationContext.GetLength((long)high);
                if (signScale!=0) len += 2;
                len = context.EncodeInt32(len);
            }
            if (low != 0)
            {
                context.WriteByte((FieldDecimalLow << 3) | (int)WireType.Variant);
                len += 1 + context.EncodeInt64((long)low);
            }
            if (high != 0)
            { // note encode as long to avoid high sign issues
                context.WriteByte((FieldDecimalHigh << 3) | (int)WireType.Variant);
                len += 1 + context.EncodeInt64((long)high);
            }
            if (signScale != 0)
            {
                context.WriteByte((FieldDecimalSignScale << 3) | (int)WireType.Variant);
                context.WriteByte((byte)signScale);
                len += 2;
            }
            return len;
        }

 public static void SerializeUnityObject(Stream stream, UnityObject obj, SerializationContext ctx)
 {
     var container = (List<UnityObject>)ctx.Context;
     var idx = container.Count;
     Basic.WriteInt32(stream, idx);
     container.Add(obj);
 }

		/// <summary>
		///		Initializes a new instance of the <see cref="SerializerEmitter"/> class for enum.
		/// </summary>
		/// <param name="context">A <see cref="SerializationContext"/>.</param>
		/// <param name="host">The host <see cref="ModuleBuilder"/>.</param>
		/// <param name="specification">The specification of the serializer.</param>
		/// <param name="isDebuggable">Set to <c>true</c> when <paramref name="host"/> is debuggable.</param>
		public SerializerEmitter( SerializationContext context, ModuleBuilder host, SerializerSpecification specification, bool isDebuggable )
			: this( host, specification, typeof( EnumMessagePackSerializer<> ).MakeGenericType( specification.TargetType ), isDebuggable )
		{
			Tracer.Emit.TraceEvent( Tracer.EventType.DefineType, Tracer.EventId.DefineType, "Create {0}", specification.SerializerTypeFullName );

			this._defaultEnumSerializationMethod = context.EnumSerializationOptions.SerializationMethod;
		}

 public static UnityObject DeserializeUnityObject(Stream stream, SerializationContext ctx)
 {
     var container = (List<UnityObject>)ctx.Context;
     int idx = Basic.ReadInt32(stream);
     if (idx < 0 || idx >= container.Count)
         return null;
     return container[idx];
 }