public override ArcFile TryOpen(ArcView file) { if (!file.View.AsciiEqual(0, "CWS") && !file.View.AsciiEqual(0, "FWS")) { return(null); } bool is_compressed = file.View.ReadByte(0) == 'C'; int version = file.View.ReadByte(3); using (var reader = new SwfReader(file.CreateStream(), version, is_compressed)) { var chunks = reader.Parse(); var base_name = Path.GetFileNameWithoutExtension(file.Name); var dir = chunks.Where(t => t.Length > 2 && TypeMap.ContainsKey(t.Type)) .Select(t => new SwfEntry { Name = string.Format("{0}#{1:D5}", base_name, t.Id), Type = GetTypeFromId(t.Type), Chunk = t, Offset = 0, Size = (uint)t.Length } as Entry).ToList(); SwfSoundEntry current_stream = null; foreach (var chunk in chunks.Where(t => IsSoundStream(t))) { switch (chunk.Type) { case Types.SoundStreamHead: case Types.SoundStreamHead2: if ((chunk.Data[1] & 0x30) != 0x20) // not mp3 stream { current_stream = null; continue; } current_stream = new SwfSoundEntry { Name = string.Format("{0}#{1:D5}", base_name, chunk.Id), Type = "audio", Chunk = chunk, Offset = 0, }; dir.Add(current_stream); break; case Types.SoundStreamBlock: if (current_stream != null) { current_stream.Size += (uint)(chunk.Data.Length - 4); current_stream.SoundStream.Add(chunk); } break; } } return(new ArcFile(file, this, dir)); } }
public static void KeysMatch(TypeMap analyzed, TypeMap test) { foreach (string key in analyzed.Keys) { Assert.IsTrue(TestTypeMaps.P3TypeMap.ContainsKey(key)); } foreach (string key in TestTypeMaps.P3TypeMap.Keys) { Assert.IsTrue(analyzed.ContainsKey(key)); } }
public string GetCardDesc(int val) { var value = val >> Digit; if (!TypeMap.ContainsKey(value)) { return(""); } return(TypeMap[value]); }
public static IMessage ReadMessage(BinaryReader reader) { var typeId = reader.ReadInt32(); if (!TypeMap.ContainsKey(typeId)) { return(null); } var messageType = TypeMap[typeId]; var message = Activator.CreateInstance(messageType) as IMessage; message.Read(reader); return(message); }
private void _populateTypeMaps(NodeProperties props, string key, bool overwrite = false) { if (key.Length > KeyLengthLimit) { KeyLengthLimitSurpassed = true; } if (!TypeMap.ContainsKey(key)) { props.Name = key; TypeMap[key] = props; return; } TypeMap[key].Update(props); }
public string GetTypeFromMap(string type) { if (TypeMap == null) { InitTypeMap(); } if (TypeMap.ContainsKey(type)) { return(TypeMap[type]); } else { if (ItemTypes.ContainsKey(type)) { return(ItemTypes[type].Type); } } return(""); }
public static void Set <T>(this RegistryKey key, T value, [CallerMemberName] string name = null) { if (value == null) { if (name != null && key.GetValue(name) != null) { key.DeleteValue(name); } return; } if (typeof(T) == typeof(bool)) { key.SetValue(name, (bool)(object)value ? 1 : 0, RegistryValueKind.DWord); return; } if (!TypeMap.ContainsKey(typeof(T))) { return; } key.SetValue(name, value, TypeMap[typeof(T)]); }
private static void AddType(Type type) { string shortName = type.Name; if (TypeMap.ContainsKey(shortName)) { shortName = type.FullName; if (TypeMap.ContainsKey(shortName)) { return; } } ShortNames.Add(type, shortName); TypeMap.Add(shortName, type); if (!type.IsGenericType) { return; } GenericTypeMap.Add(shortName.Replace("`1", ""), type); GenericShortNames.Add(type, shortName.Replace("`1", "")); }
public bool ContainsType(IType type) { return(TypeMap.ContainsKey(type)); }
public bool Exists(Type type) => TypeMap.ContainsKey(type.FullName);
/// <summary> /// checks if a type is supported via the TypeMap table. /// </summary> /// <param name="dataType">type to check</param> /// <returns></returns> public static bool IsSupported(Type dataType) { return(TypeMap.ContainsKey(Type.GetTypeCode(dataType))); }
private Type VisitAnonymous(Type type) { Debug.Assert(type.IsAnonymousType()); var newType = default(Type); var getNewCtor = default(Func <NewExpression, Func <Expression, Expression>, Expression>); var getNewMember = default(Func <MemberExpression, Func <Expression, Expression>, Expression>); var convertConstant = default(Func <object, Func <object, object>, object>); var oldCtor = type.GetConstructors().Single(); var oldPars = oldCtor.GetParameters(); var n = oldPars.Length; if (n == 0) { newType = _unit.Type; getNewCtor = (ne, _) => _unit; convertConstant = (ce, _) => _unit.Evaluate <object>(); } else { var ctors = new List <ConstructorInfo>(); var props = new Dictionary <MemberInfo, Stack <PropertyInfo> >(); var convp = Expression.Parameter(type); var convr = Expression.Parameter(typeof(Func <object, object>)); var conve = default(Expression); var oldProps = type.GetProperties().ToDictionary(p => p.Name, p => p); var max = ExpressionTupletizer.TupleTypeCount - 2 /* T1..T7 */; var fst = (n / max) * max; var rem = n - fst; if (rem == 0) { fst = n - max; rem = max; } for (var i = fst; i >= 0; i -= max) { var tupleArgs = default(Type[]); var constArgs = default(Expression[]); if (newType == null) { tupleArgs = new Type[rem]; constArgs = new Expression[rem]; } else { tupleArgs = new Type[rem + 1]; tupleArgs[rem] = newType; constArgs = new Expression[rem + 1]; constArgs[rem] = conve; } var originalProps = new List <PropertyInfo>(rem); for (var j = 0; j < rem; j++) { var par = oldPars[i + j]; var prop = oldProps[par.Name]; tupleArgs[j] = Visit(par.ParameterType); originalProps.Add(prop); } newType = ExpressionTupletizer.TupleTypes[tupleArgs.Length].MakeGenericType(tupleArgs); var ctor = newType.GetConstructor(tupleArgs); ctors.Add(ctor); if (rem == max) { var rest = newType.GetProperty("Rest"); foreach (var kv in props) { kv.Value.Push(rest); } } var ctorPars = ctor.GetParameters(); for (var j = 0; j < originalProps.Count; j++) { var prop = originalProps[j]; var newProp = new Stack <PropertyInfo>(); var item = newType.GetProperty("Item" + (j + 1)); newProp.Push(item); props[prop] = newProp; var member = (Expression)Expression.MakeMemberAccess(convp, prop); if (TypeMap.ContainsKey(prop.PropertyType)) { member = Expression.Convert(Expression.Invoke(convr, member), item.PropertyType); } else { var ctorParameterType = ctorPars[j].ParameterType; var argType = member.Type; if (!ctorParameterType.IsAssignableFrom(argType)) { var cantConvertMsg = string.Format(CultureInfo.InvariantCulture, "Can't convert constant of type '{0}' to '{1}'.", argType, ctorParameterType); var cantConvertException = Expression.New(InvalidOperationExceptionCtor, Expression.Constant(cantConvertMsg)); member = Expression.Throw(cantConvertException, ctorParameterType); } } constArgs[j] = member; } conve = Expression.New(ctor, constArgs); rem = max; } getNewCtor = (ne, visit) => { var res = default(Expression); var args = ne.Arguments.Select(visit).ToArray(); var k = args.Length; foreach (var c in ctors) { var paras = c.GetParameters(); var m = paras.Length; var bundle = new Expression[m]; if (res != null) { bundle[m - 1] = res; m--; } k -= m; for (var j = 0; j < m; j++) { bundle[j] = args[k + j]; } res = Expression.New(c, bundle); } return(res); }; getNewMember = (me, visit) => { var expr = visit(me.Expression); foreach (var p in props[me.Member]) { expr = Expression.MakeMemberAccess(expr, p); } return(expr); }; var convf = Expression.Lambda(conve, convp, convr); var convd = default(Delegate); convertConstant = (cst, visit) => { if (convd == null) { convd = convf.Compile(); } return(convd.DynamicInvoke(cst, visit)); }; } TypeMap[type] = newType; ConstructorMap[type] = getNewCtor; PropertyMap[type] = getNewMember; ConstantConverters[type] = convertConstant; return(newType); }