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));
}
