internal MemberMapping(MemberInfo member, MemberAttribute attribute, EntityMapping entity) { this.member = member; this.entity = entity; memberType = member.GetMemberType(); var isEnumerableType = memberType != Types.String && memberType != typeof(byte[]) && Types.IEnumerable.IsAssignableFrom(memberType); if (attribute == null) { InitializeConversionMapping(isEnumerableType); } else InitializeAttributeMapping(attribute, isEnumerableType); getter = member.GetGetter(); if (storageMember != null) setter = storageMember.GetSetter(); else setter = member.GetSetter(); if (columnName == null) columnName = member.Name; }
static bool CheckStuff () { if (resed == null) return false; Program.result = resed (); resed = null; return true; }
public static void RegisterMultiFileDragDrop(Control c, MultiFileReceiver r, Getter<string> filter) { c.AllowDrop = true; c.DragEnter += delegate(object sender, DragEventArgs e) { e.Effect = DragDropEffects.None; if (e.Data.GetDataPresent(DataFormats.FileDrop)) { string[] files = (string[])e.Data.GetData(DataFormats.FileDrop, false); if (files.Length > 0 && Array.Exists<string>(files, delegate(string s) { return FileUtil.MatchesFilter(filter(), s); })) e.Effect = DragDropEffects.All; } }; c.DragDrop += delegate(object sender, DragEventArgs e) { r(Array.FindAll<string>(((string[])e.Data.GetData(DataFormats.FileDrop, false)), delegate(string s) { return FileUtil.MatchesFilter(filter(), s); })); }; }
public FieldBlank(string fieldName, Getter<object, object> toGridValue, Getter<object, object> toDataBaseValue, object defaultValue) { this.FieldName = fieldName; this.ToGridValue = toGridValue; this.ToDataBaseValue = toDataBaseValue; this.DefaultValue = defaultValue; }
LocalVariable(IMethod method, int index, IType type, string name, ILRange[] ilranges, Getter getter) { this.Method = method; this.Index = index; this.Type = type; this.Name = name; this.ILRanges = ilranges; this.getter = getter; }
public ComplexDynamicProperty( Getter getter, Setter setter, bool useInitialValue = false, object initialValue = null) { this.getter = getter; this.setter = setter; if (useInitialValue) { setter(initialValue); } }
private static string[] GetParts(CacheKey[] namespaceCacheKeys, string[] keyParts) { List<string> returnList = new List<string>(); string[] versionKeys = namespaceCacheKeys.ConvertAll(key => key.ToString()); Getter<string>[] getters = new Getter<string>[namespaceCacheKeys.Length]; getters.Length.Times(i => getters[i] = () => Guid.NewGuid().ToString()); string[] versionValues = Caching.Instances.Main.MultiGet<string>(versionKeys, getters, DateTime.MaxValue); returnList.AddRange(versionValues); returnList.AddRange(keyParts); return returnList.ToArray(); }
/// <summary> /// Use this constructor to create child nodes. /// </summary> /// <param name="type">The type of the field this node represets</param> /// <param name="name">The name of the field this node represets</param> /// <param name="setter">Helper delegate to set the value of the field.</param> /// <param name="getter">Helper delegate to get the value of the field.</param> public InspectorNode(InspectorNode parent, Type type, String name, Setter setter, Getter getter, bool hideCanWriteIcon) { Children = new ObservableCollection<InspectorNode>(); Methods = new ObservableCollection<InspectorNode>(); Name = name; Type = type; _setter = setter; _getter = getter; Parent = parent; Updating = true; _hideCantWriteIcon = hideCanWriteIcon; }
internal static void PackArgs(Stream stream, MethodInfo method, object result, object[] args, Getter<ParameterInfo, bool> predicate) { ParameterInfo[] parameters = method.GetParameters(); if (result != null && method.ReturnType != typeof(void)) { Serializer.NonGeneric.SerializeWithLengthPrefix(stream, result, PrefixStyle.Base128, 1); } for (int i = 0; i < parameters.Length; i++) { ParameterInfo p = parameters[i]; if (predicate(p) && args[i] != null) { Serializer.NonGeneric.SerializeWithLengthPrefix(stream, args[i], PrefixStyle.Base128, i + 2); } } }
public override object Get(object onObject) { if (null == _getter) _getter = AccessorFactory.GetterFor(_field); try { return _getter(onObject); } catch (FieldAccessException) { _getter = _field.GetValue; return _getter(onObject); } catch (Exception e) { throw new Db4oException(e); } }
public void WhenIReadBackAllMachineDesignsFrom(string getDesignUri) { var designGetter = new Getter <GetMachineDesignResult>(string.Format(RestClient.Productivity3DServiceBaseUrl + getDesignUri)); getMachineDesignResult = designGetter.SendRequest(designGetter.Uri); }
public void InitModel(Getter<Model> modelGetter) { GetModel = modelGetter; GetModel().Load(loader()); ForceSynchronize(); }
public ModelStateManager(Getter<Model> loader, Executter<Model> saver) { this.loader = loader; this.saver = saver; }
public EntityMemberMapping(MemberModel memberModel, ValidationAttribute attr) { Member = memberModel.Member; Name = memberModel.Name; Getter = memberModel.GetMember; ValidationAttribute = attr; var displayNameAttr = Member.GetAttribute<DisplayNameAttribute>(false); DisplayName = displayNameAttr != null ? displayNameAttr.DisplayName : Member.Name; }
public void Generate(GenBase gen, StreamWriter sw, string indent, CodeGenerationOptions opt, bool with_callbacks, bool force_override) { // <TechnicalDebt> // This is a special workaround for AdapterView inheritance. // (How it is special? They have hand-written bindings AND brings generic // version of AdapterView<T> in the inheritance, also added by metadata!) // // They are on top of fragile hand-bound code, and when we are making changes // in generator, they bite. Since we are not going to bring API breakage // right now, we need special workarounds to get things working. // // So far, what we need here is to have AbsSpinner.Adapter compile. // // > platforms/*/src/generated/Android.Widget.AbsSpinner.cs(156,56): error CS0533: // > `Android.Widget.AbsSpinner.Adapter' hides inherited abstract member // > `Android.Widget.AdapterView<Android.Widget.ISpinnerAdapter>.Adapter // // It is because the AdapterView<T>.Adapter is hand-bound and cannot be // detected by generator! // // So, we explicitly treat it as a special-case. // // Then, Spinner, ListView and GridView instantiate them, so they are also special cases. // </TechnicalDebt> if (Name == "Adapter" && (Getter.DeclaringType.BaseGen.FullName == "Android.Widget.AdapterView" || Getter.DeclaringType.BaseGen.BaseGen != null && Getter.DeclaringType.BaseGen.BaseGen.FullName == "Android.Widget.AdapterView")) { force_override = true; } // ... and the above breaks generator tests... if (Name == "Adapter" && (Getter.DeclaringType.BaseGen.FullName == "Xamarin.Test.AdapterView" || Getter.DeclaringType.BaseGen.BaseGen != null && Getter.DeclaringType.BaseGen.BaseGen.FullName == "Xamarin.Test.AdapterView")) { force_override = true; } string decl_name = AdjustedName; string needNew = gen.RequiresNew(decl_name) ? " new" : ""; string virtual_override = String.Empty; bool is_virtual = Getter.IsVirtual && (Setter == null || Setter.IsVirtual); if (with_callbacks && is_virtual) { virtual_override = needNew + " virtual"; Getter.GenerateCallback(sw, indent, opt, gen, AdjustedName); } if (with_callbacks && is_virtual && Setter != null) { virtual_override = needNew + " virtual"; Setter.GenerateCallback(sw, indent, opt, gen, AdjustedName); } virtual_override = force_override ? " override" : virtual_override; if ((Getter ?? Setter).IsStatic) { virtual_override = " static"; } // It should be using AdjustedName instead of Name, but ICharSequence ("Formatted") properties are not caught by this... else if (gen.BaseSymbol != null && gen.BaseSymbol.GetPropertyByName(Name, true) != null) { virtual_override = needNew + " override"; } Getter.GenerateIdField(sw, indent, opt); if (Setter != null) { Setter.GenerateIdField(sw, indent, opt); } string visibility = Getter.IsAbstract && Getter.RetVal.IsGeneric ? "protected" : (Setter ?? Getter).Visibility; // Unlike [Register], mcs does not allow applying [Obsolete] on property accessors, so we can apply them only under limited condition... if (Getter.Deprecated != null && (Setter == null || Setter.Deprecated != null)) { sw.WriteLine("{0}[Obsolete (@\"{1}\")]", indent, Getter.Deprecated.Replace("\"", "\"\"").Trim() + (Setter != null && Setter.Deprecated != Getter.Deprecated ? " " + Setter.Deprecated.Replace("\"", "\"\"").Trim() : null)); } Getter.GenerateCustomAttributes(sw, indent); sw.WriteLine("{0}{1}{2} unsafe {3} {4} {{", indent, visibility, virtual_override, opt.GetOutputName(Getter.ReturnType), decl_name); if (gen.IsGeneratable) { sw.WriteLine("{0}\t// Metadata.xml XPath method reference: path=\"{1}/method[@name='{2}'{3}]\"", indent, gen.MetadataXPathReference, Getter.JavaName, Getter.Parameters.GetMethodXPathPredicate()); } sw.WriteLine("{0}\t[Register (\"{1}\", \"{2}\", \"{3}\"{4})]", indent, Getter.JavaName, Getter.JniSignature, Getter.ConnectorName, Getter.AdditionalAttributeString()); sw.WriteLine("{0}\tget {{", indent); Getter.GenerateBody(sw, indent + "\t\t", opt); sw.WriteLine("{0}\t}}", indent); if (Setter != null) { if (gen.IsGeneratable) { sw.WriteLine("{0}\t// Metadata.xml XPath method reference: path=\"{1}/method[@name='{2}'{3}]\"", indent, gen.MetadataXPathReference, Setter.JavaName, Setter.Parameters.GetMethodXPathPredicate()); } Setter.GenerateCustomAttributes(sw, indent); sw.WriteLine("{0}\t[Register (\"{1}\", \"{2}\", \"{3}\"{4})]", indent, Setter.JavaName, Setter.JniSignature, Setter.ConnectorName, Setter.AdditionalAttributeString()); sw.WriteLine("{0}\tset {{", indent); string pname = Setter.Parameters [0].Name; Setter.Parameters [0].Name = "value"; Setter.GenerateBody(sw, indent + "\t\t", opt); Setter.Parameters [0].Name = pname; sw.WriteLine("{0}\t}}", indent); } else if (GenerateDispatchingSetter) { sw.WriteLine("{0}// This is a dispatching setter", indent + "\t"); sw.WriteLine("{0}set {{ Set{1} (value); }}", indent + "\t", Name); } sw.WriteLine("{0}}}", indent); sw.WriteLine(); if (Type.StartsWith("Java.Lang.ICharSequence") && virtual_override != " override") { GenerateStringVariant(sw, indent); } }
static Log4NetLogger() { try { var asm = NLite.Reflection.AssemblyLoader.Load("log4net"); if (asm == null) return; LogManagerType = asm.GetType("log4net.LogManager"); if (LogManagerType == null) return; GetLoggerByNameDelegate = LogManagerType.GetMethod("GetLogger", new Type[] { typeof(string) }).GetFunc(); GetLoggerByTypeDelegate = LogManagerType.GetMethod("GetLogger", new Type[] { typeof(Type) }).GetFunc(); var loggerType = LogManagerType.Assembly.GetType("log4net.ILog"); IsErrorEnabledDelegate = loggerType.GetProperty("IsErrorEnabled").GetGetter(); IsFatalEnabledDelegate = loggerType.GetProperty("IsFatalEnabled").GetGetter(); IsDebugEnabledDelegate = loggerType.GetProperty("IsDebugEnabled").GetGetter(); IsInfoEnabledDelegate = loggerType.GetProperty("IsInfoEnabled").GetGetter(); IsWarnEnabledDelegate = loggerType.GetProperty("IsWarnEnabled").GetGetter(); ErrorDelegate = loggerType.GetMethod("Error", new Type[] { typeof(object) }).GetProc(); ErrorExceptionDelegate = loggerType.GetMethod("Error", new Type[] { typeof(object), typeof(Exception) }).GetProc(); ErrorFormatDelegate = loggerType.GetMethod("ErrorFormat", new Type[] { typeof(string), typeof(object[]) }).GetProc(); FatalDelegate = loggerType.GetMethod("Fatal", new Type[] { typeof(object) }).GetProc(); FatalExceptionDelegate = loggerType.GetMethod("Fatal", new Type[] { typeof(object), typeof(Exception) }).GetProc(); DebugDelegate = loggerType.GetMethod("Debug", new Type[] { typeof(object) }).GetProc(); DebugExceptionDelegate = loggerType.GetMethod("Debug", new Type[] { typeof(object), typeof(Exception) }).GetProc(); DebugFormatDelegate = loggerType.GetMethod("DebugFormat", new Type[] { typeof(string), typeof(object[]) }).GetProc(); InfoDelegate = loggerType.GetMethod("Info", new Type[] { typeof(object) }).GetProc(); InfoExceptionDelegate = loggerType.GetMethod("Info", new Type[] { typeof(object), typeof(Exception) }).GetProc(); InfoFormatDelegate = loggerType.GetMethod("InfoFormat", new Type[] { typeof(string), typeof(object[]) }).GetProc(); WarnDelegate = loggerType.GetMethod("Warn", new Type[] { typeof(object) }).GetProc(); WarnExceptionDelegate = loggerType.GetMethod("Warn", new Type[] { typeof(object), typeof(Exception) }).GetProc(); WarnFormatDelegate = loggerType.GetMethod("WarnFormat", new Type[] { typeof(string), typeof(object[]) }).GetProc(); } catch { } finally { } }
public sealed override MethodInfo GetGetMethod(bool nonPublic) => Getter?.FilterAccessor(nonPublic);
public void GenerateDeclaration(StreamWriter sw, string indent, CodeGenerationOptions opt, GenBase gen, string adapter) { sw.WriteLine("{0}{1} {2} {{", indent, opt.GetOutputName(Type), AdjustedName); if (Getter != null) { if (gen.IsGeneratable) { sw.WriteLine("{0}\t// Metadata.xml XPath method reference: path=\"{1}/method[@name='{2}'{3}]\"", indent, gen.MetadataXPathReference, Getter.JavaName, Getter.Parameters.GetMethodXPathPredicate()); } if (Getter.GenericArguments != null && Getter.GenericArguments.Any()) { sw.WriteLine("{0}{1}", indent, Getter.GenericArguments.ToGeneratedAttributeString()); } sw.WriteLine("{0}\t[Register (\"{1}\", \"{2}\", \"{3}:{4}\"{5})] get;", indent, Getter.JavaName, Getter.JniSignature, Getter.ConnectorName, Getter.GetAdapterName(opt, adapter), Getter.AdditionalAttributeString()); } if (Setter != null) { if (gen.IsGeneratable) { sw.WriteLine("{0}\t// Metadata.xml XPath method reference: path=\"{1}/method[@name='{2}'{3}]\"", indent, gen.MetadataXPathReference, Setter.JavaName, Setter.Parameters.GetMethodXPathPredicate()); } if (Setter.GenericArguments != null && Setter.GenericArguments.Any()) { sw.WriteLine("{0}{1}", indent, Setter.GenericArguments.ToGeneratedAttributeString()); } sw.WriteLine("{0}\t[Register (\"{1}\", \"{2}\", \"{3}:{4}\"{5})] set;", indent, Setter.JavaName, Setter.JniSignature, Setter.ConnectorName, Setter.GetAdapterName(opt, adapter), Setter.AdditionalAttributeString()); } sw.WriteLine("{0}}}", indent); sw.WriteLine(); }
internal static object UnpackArgs(Stream stream, MethodInfo method, object[] args, Getter<ParameterInfo, bool> predicate) { ParameterInfo[] parameters = method.GetParameters(); if (args.Length != parameters.Length) throw new ArgumentException("The argument and parameter count do not agree"); for (int i = 0; i < parameters.Length; i++) { if (predicate(parameters[i])) args[i] = null; // if the } object result = null, lastItem; int lastPos = -1; while (Serializer.NonGeneric.TryDeserializeWithLengthPrefix(stream, PrefixStyle.Base128, delegate(int tag) { lastPos = tag - 2; if (lastPos == -1) { return method.ReturnType == typeof(void) ? null : method.ReturnType; } else if (lastPos >= 0 && lastPos < args.Length && predicate(parameters[lastPos])) { return parameters[lastPos].ParameterType; } return null; }, out lastItem)) { if (lastPos == -1) { result = lastItem; } else { args[lastPos] = lastItem; } } return result; }
public void GenerateExplicitIface(StreamWriter sw, string indent, CodeGenerationOptions opt, GenericSymbol gen, string adapter) { Dictionary <string, string> mappings = new Dictionary <string, string> (); for (int i = 0; i < gen.TypeParams.Length; i++) { mappings [gen.Gen.TypeParameters [i].Name] = gen.TypeParams [i].FullName; } //If the property type is Java.Lang.Object, we don't need to generate an explicit implementation if (Getter?.RetVal.GetGenericType(mappings) == "Java.Lang.Object") { return; } if (Setter?.Parameters[0].GetGenericType(mappings) == "Java.Lang.Object") { return; } sw.WriteLine("{0}// This method is explicitly implemented as a member of an instantiated {1}", indent, gen.FullName); sw.WriteLine("{0}{1} {2}.{3} {{", indent, opt.GetOutputName(Type), opt.GetOutputName(gen.Gen.FullName), AdjustedName); if (Getter != null) { if (gen.Gen.IsGeneratable) { sw.WriteLine("{0}\t// Metadata.xml XPath method reference: path=\"{1}/method[@name='{2}'{3}]\"", indent, gen.Gen.MetadataXPathReference, Getter.JavaName, Getter.Parameters.GetMethodXPathPredicate()); } if (Getter.GenericArguments != null && Getter.GenericArguments.Any()) { sw.WriteLine("{0}{1}", indent, Getter.GenericArguments.ToGeneratedAttributeString()); } sw.WriteLine("{0}\t[Register (\"{1}\", \"{2}\", \"{3}:{4}\"{5})] get {{", indent, Getter.JavaName, Getter.JniSignature, Getter.ConnectorName, Getter.GetAdapterName(opt, adapter), Getter.AdditionalAttributeString()); sw.WriteLine("{0}\t\treturn {1};", indent, Name); sw.WriteLine("{0}\t}}", indent); } if (Setter != null) { if (gen.Gen.IsGeneratable) { sw.WriteLine("{0}\t// Metadata.xml XPath method reference: path=\"{1}/method[@name='{2}'{3}]\"", indent, gen.Gen.MetadataXPathReference, Setter.JavaName, Setter.Parameters.GetMethodXPathPredicate()); } if (Setter.GenericArguments != null && Setter.GenericArguments.Any()) { sw.WriteLine("{0}{1}", indent, Setter.GenericArguments.ToGeneratedAttributeString()); } sw.WriteLine("{0}\t[Register (\"{1}\", \"{2}\", \"{3}:{4}\"{5})] set {{", indent, Setter.JavaName, Setter.JniSignature, Setter.ConnectorName, Setter.GetAdapterName(opt, adapter), Setter.AdditionalAttributeString()); sw.WriteLine("{0}\t\t{1} = {2};", indent, Name, Setter.Parameters.GetGenericCall(opt, mappings)); sw.WriteLine("{0}\t}}", indent); } sw.WriteLine("{0}}}", indent); sw.WriteLine(); }
public override object Get(object onObject) { if (null == _getter) _getter = new GetFieldEmitter(field).Emit(); return _getter(onObject); }
public XGPControlCell() { RelativeXGP = new List<XGPControlCell>(); Enabled = true; Offset = ofst => { if (TargetParameter == null) { return; } TargetParameter.OffsetValue(ofst); }; GetTextFunc = () => TargetParameter != null ? TargetParameter.ValueString : Text; GetDescriptionFunc = () => TargetParameter != null ? (TargetParameter.Description ?? TargetParameter.Name ?? "") : ""; Increment = () => Offset(1); Decrement = () => Offset(-1); Trigger = () => { }; }
public InputFunction(Getter getter, Range range = null) { Range = range == null ? Range.Infinite : range; Get = getter; }
public void InitModel(Getter<Model> modelGetter) { this.GetModel = modelGetter; }
public CustomProperty(Getter getter, Setter setter) { _getter = getter; _setter = setter; }
public void AndIReadBackAllLiftsFrom(string getLiftUri) { var liftGetter = new Getter <LayerIdsExecutionResult>(string.Format(RestClient.Productivity3DServiceBaseUrl + getLiftUri)); layerIdsExecutionResult = liftGetter.SendRequest(liftGetter.Uri); }
public LinkConstraint(bool isForeign, Getter<bool, IRowLink> isValidRow) { this.IsForeign = isForeign; this.IsValidRow = isValidRow; }
static void Main() { var sss = new Getter(12); Console.WriteLine($"Area of the square = {sss.Constructor()}"); }
public static void RegisterSingleFileDragDrop(Control c, SingleFileReceiver r, Getter<string> filter) { c.AllowDrop = true; c.DragEnter += delegate(object sender, DragEventArgs e) { e.Effect = DragDropEffects.None; if (e.Data.GetDataPresent(DataFormats.FileDrop)) { string[] files = (string[])e.Data.GetData(DataFormats.FileDrop, false); if (files.Length == 1 && FileUtil.MatchesFilter(filter(), files[0])) e.Effect = DragDropEffects.All; } }; c.DragDrop += delegate(object sender, DragEventArgs e) { r(((string[])e.Data.GetData(DataFormats.FileDrop, false))[0]); }; }
internal void ReplaceGetter(Getter gt) { if (gt == null) getMethod = new Getter(val_getter); else getMethod = gt; }
public Updater(Getter getter, Setter setter) { m_Getter = getter; m_Setter = setter; }
protected LazyMaker(Executter<object[]> maker, params Getter<object>[] sources) { this.maker = maker; this.sources = sources; this.cacheArgs = new object[sources.Length]; }
public Host (Getter g) { this.g = g; }
/// <summary> /// Deserialize object of unknown types from in input stream. /// </summary> /// <param name="source">The input stream.</param> /// <param name="style">The prefix style used to encode the lengths.</param> /// <param name="typeReader">The caller must provide a mechanism to resolve a Type from /// the tags encountered in the stream. If the delegate returns null, then the instance /// is skipped - otherwise, the object is deserialized according to type.</param> /// <param name="item">The deserialized instance, or null if the stream terminated.</param> /// <returns>True if an object was idenfified; false if the stream terminated. Note /// that unexpected types are skipped.</returns> public static bool TryDeserializeWithLengthPrefix(Stream source, PrefixStyle style, Getter<int,Type> typeReader, out object item) { uint len; Type itemType = null; Getter<int, bool> processField = null; if(typeReader != null) processField = delegate(int checkTag) { itemType = typeReader(checkTag); return itemType != null; }; if(!Serializer.TryReadPrefixLength(source, style, 1, out len, processField)) { item = null; return false; } if (len == uint.MaxValue) { item = NonGeneric.Deserialize(itemType, source); } else { using (SubStream subStream = new SubStream(source, len, false)) { item = NonGeneric.Deserialize(itemType, subStream); } } return true; }
public LinkConstraint(Getter<bool, IRowLink> isValidRow) : this(false, isValidRow) { }
public void AddOptionRecord(AbstractOptionRecord record, Getter getter, Setter setter) { OptionRecords.Add(record.Name, record); Define(record.Name, getter, setter); }
public static void PrepareStyle( IPlotGroupStyleCollection externalGroups, IPlotGroupStyleCollection localGroups, Getter getter) { if (!externalGroups.ContainsType(typeof(ColorGroupStyle)) && null != localGroups && !localGroups.ContainsType(typeof(ColorGroupStyle))) { localGroups.Add(new ColorGroupStyle()); } ColorGroupStyle grpStyle = null; if (externalGroups.ContainsType(typeof(ColorGroupStyle))) grpStyle = (ColorGroupStyle)externalGroups.GetPlotGroupStyle(typeof(ColorGroupStyle)); else if (localGroups != null) grpStyle = (ColorGroupStyle)localGroups.GetPlotGroupStyle(typeof(ColorGroupStyle)); if (grpStyle != null && getter != null && !grpStyle.IsInitialized) grpStyle.Initialize(getter()); }
private static object GetterAdapterFrame <T, R>(Getter <T, R> getter, object obj) { return(getter((T)obj)); }