public void LoadClasses(ClassLoader parentClassLoader) { ClassesMayNull = new List<Type>(); // The assembly is the container for all the types, there is no need to explicitly // load them as is done in Java. In Esper, the class is loaded as a byte array which // the ByteArrayProvidingClassProvider must initialize. foreach (var clazz in Assembly.GetExportedTypes()) { ClassesMayNull.Add(clazz); } }
/// <summary> /// Generate a proxy class. Must call the checkProxyAccess method /// to perform permission checks before calling this. /// </summary> private static Class GetProxyClass0(ClassLoader loader, params Class[] interfaces) { if (interfaces.Length > 65535) { throw new IllegalArgumentException("interface limit exceeded"); } // If the proxy class defined by the given loader implementing // the given interfaces exists, this will simply return the cached copy; // otherwise, it will create the proxy class via the ProxyClassFactory return(ProxyClassCache.Get(loader, interfaces)); }
void executePrivate( ) { /* GeneXus formulas */ /* Output device settings */ args = new Object[] { (long)AV2TanqueroBandaCPSUAB, (long)AV3TanqueroBandaTM, (long)AV4DWT, (SdtSdtResultado)AV5SdtResultado }; ClassLoader.Execute("acalculartanqueros", "GeneXus.Programs.acalculartanqueros", new Object[] { context }, "execute", args); if ((args != null) && (args.Length == 4)) { AV5SdtResultado = (SdtSdtResultado)(args[3]); } this.cleanup(); }
/// <summary> /// Constructs a new URLClassLoader for the specified URLs, parent /// class loader, and URLStreamHandlerFactory. The parent argument /// will be used as the parent class loader for delegation. The /// factory argument will be used as the stream handler factory to /// obtain protocol handlers when creating new jar URLs. /// /// <para>If there is a security manager, this method first /// calls the security manager's {@code checkCreateClassLoader} method /// to ensure creation of a class loader is allowed. /// /// </para> /// </summary> /// <param name="urls"> the URLs from which to load classes and resources </param> /// <param name="parent"> the parent class loader for delegation </param> /// <param name="factory"> the URLStreamHandlerFactory to use when creating URLs /// </param> /// <exception cref="SecurityException"> if a security manager exists and its /// {@code checkCreateClassLoader} method doesn't allow /// creation of a class loader. </exception> /// <exception cref="NullPointerException"> if {@code urls} is {@code null}. </exception> /// <seealso cref= SecurityManager#checkCreateClassLoader </seealso> public URLClassLoader(URL[] urls, ClassLoader parent, URLStreamHandlerFactory factory) : base(parent) { // this is to make the stack depth consistent with 1.1 SecurityManager security = System.SecurityManager; if (security != null) { security.CheckCreateClassLoader(); } Ucp = new URLClassPath(urls, factory); Acc = AccessController.Context; }
/// <summary> /// Creates a new service loader for the given service type, using the /// extension class loader. /// /// <para> This convenience method simply locates the extension class loader, /// call it <tt><i>extClassLoader</i></tt>, and then returns /// /// <blockquote><pre> /// ServiceLoader.load(<i>service</i>, <i>extClassLoader</i>)</pre></blockquote> /// /// </para> /// <para> If the extension class loader cannot be found then the system class /// loader is used; if there is no system class loader then the bootstrap /// class loader is used. /// /// </para> /// <para> This method is intended for use when only installed providers are /// desired. The resulting service will only find and load providers that /// have been installed into the current Java virtual machine; providers on /// the application's class path will be ignored. /// /// </para> /// </summary> /// @param <S> the class of the service type /// </param> /// <param name="service"> /// The interface or abstract class representing the service /// </param> /// <returns> A new service loader </returns> public static ServiceLoader <S> loadInstalled <S>(Class service) { ClassLoader cl = ClassLoader.SystemClassLoader; ClassLoader prev = null; while (cl != null) { prev = cl; cl = cl.Parent; } return(ServiceLoader.Load(service, prev)); }
public override IDbDataParameter CreateParameter(string name, Object dbtype, int gxlength, int gxdec) { object ifxType = GXTypeToIfxType((GXType)dbtype); object[] args = new object[] { name, ifxType, gxlength }; IDbDataParameter parm = (IDbDataParameter)ClassLoader.CreateInstance(IfxAssembly, "IBM.Data.Informix.IfxParameter", args); ClassLoader.SetPropValue(parm, "IfxType", ifxType); parm.Precision = (byte)gxdec; parm.Scale = (byte)gxdec; return(parm); }
internal URLClassLoader(URL[] urls, ClassLoader parent, AccessControlContext acc) : base(parent) { // this is to make the stack depth consistent with 1.1 SecurityManager security = System.SecurityManager; if (security != null) { security.CheckCreateClassLoader(); } Ucp = new URLClassPath(urls); this.Acc = acc; }
private static void Main(string[] args) { var app = new CommandLineApplication { Name = "dynamo2terraform" }; app.HelpOption("-?|-h|--help"); var inputFilePathOption = app.Option("-i|--input <path>", "The path to the input C# DynamoDB Model decorated with DynamoDBAttributes for parsing", CommandOptionType.SingleValue); var templateFilePathOption = app.Option("-t|--template <path>", "The path to the liquid template to be used for generating the output", CommandOptionType.SingleValue); app.OnExecute(() => { if (!inputFilePathOption.HasValue() || !File.Exists(inputFilePathOption.Value())) { Console.WriteLine("Could not find Input file at the path provided"); return(0); } if (!templateFilePathOption.HasValue() || !File.Exists(templateFilePathOption.Value())) { Console.WriteLine("Could not find Liquid template file at path provided"); return(0); } var tree = ClassLoader.GetSyntaxTreeFromPath(inputFilePathOption.Value()); var table = DynamoParserService.Parse(tree); var liquidTemplate = File.ReadAllText(templateFilePathOption.Value()); IEnumerable <string> errors; if (FluidTemplate.TryParse(liquidTemplate, out var template, out errors)) { var context = new TemplateContext(); context.MemberAccessStrategy.Register(typeof(DynamoDbTable)); // Allows any public property of the model to be used context.MemberAccessStrategy.Register(typeof(DynamoDbAttribute)); context.MemberAccessStrategy.Register(typeof(DynamoDbGlobalSecondaryIndex)); context.SetValue("table", table); Console.WriteLine(template.Render(context)); } return(0); }); app.Execute(args); }
/// <summary> /// The connect. /// </summary> /// <param name="context"> /// The context. /// </param> public void Connect(Context context) { this.classLoader = context.ClassLoader; var bindIntent = new Intent(context, this.serviceTypeType); bindIntent.PutExtra(ClientMessageParameters.Messenger, this.messenger); bool bound = context.BindService(bindIntent, this.serviceConnection, Bind.DebugUnbind); if (!bound) { Debug.WriteLine("LVLDL Service Unbound"); } }
public static BpmPlatformPlugins load(ClassLoader classLoader) { BpmPlatformPlugins plugins = new BpmPlatformPlugins(); IEnumerator <BpmPlatformPlugin> it = ServiceLoader.load(typeof(BpmPlatformPlugin), classLoader).GetEnumerator(); while (it.MoveNext()) { plugins.add(it.Current); } return(plugins); }
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET: //ORIGINAL LINE: public static <T> T runUnderClassloader(final Operation<T> operation, final ClassLoader classLoader) public static T runUnderClassloader <T>(Operation <T> operation, ClassLoader classLoader) { SecurityManager sm = System.SecurityManager; if (sm != null) { return(AccessController.doPrivileged(new PrivilegedActionAnonymousInnerClass(operation, classLoader))); } else { return(runWithTccl(operation, classLoader)); } }
/// <summary> /// This method is not part of the API, though it can be used (reflectively) by clients of this /// class to remove entries from the cache when the beans are being unloaded. /// /// Note: this method is present in the reference implementation, so we're adding it here to ease /// migration. /// </summary> /// <param name="classloader"> /// The classLoader used to load the beans. </param> //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @SuppressWarnings("unused") private final void purgeBeanClasses(ClassLoader loader) private void purgeBeanClasses(ClassLoader loader) { IEnumerator <Type> classes = cache.Keys.GetEnumerator(); while (classes.MoveNext()) { if (loader == classes.Current.ClassLoader) { //JAVA TO C# CONVERTER TODO TASK: .NET enumerators are read-only: classes.remove(); } } }
public Server() { Debug.WriteLine("Entering Server ctor"); // Log not yet ready here _server = this; Config.Init(); Log.Init(); // Initialize World Details ClassLoader.Init(); Log.Verbose("Leaving Server ctor"); }
public static Form ShowNormal (Type typeForm, IObject bo, Dictionary <string, object> parameters = null, int width = 0, int height = 0) { if (typeForm == null) { return(null); } using (new WaitDialog()) { var o = ClassLoader.LoadClass(typeForm); return(ShowNormal(o as IApplicationForm, bo, parameters, width, height)); } }
public PetitClrInterpreter(ClassLoader classLoader, MethodDefinition methodDef, bool directCall, IList <ObjectInstance> args, object stubContext) { _classLoader = classLoader; _methInfo2 = methodDef; _directCall = directCall; _args = args; _stubContext = stubContext; _instructions = methodDef.Body.Instructions.ToArray(); _instructionPtr = 0; _opStack = new Stack <ObjectInstance>(); _localSlot = new ObjectInstance[methodDef.Body.Variables.Count]; }
internal static decimal GetIfxDecimal(IDataReader reader, int i) { try { decimal result; string ifxDecimal = ClassLoader.Invoke(reader, "GetIfxDecimal", new object[] { i }).ToString(); Decimal.TryParse(ifxDecimal, NumberStyles.Number, CultureInfo.InvariantCulture, out result); return(result); }catch (Exception) { return(Convert.ToInt64(reader.GetValue(i))); } }
/** * Constructor. */ private ModuleContext(ClassLoader loader) { _loader = loader; _marshalFactory = new MarshalFactory(this); _exprFactory = new ExprFactory(); string [] empty = new String[0]; _stdClassDef = new InterpretedClassDef("stdClass", null, empty, empty); _stdClass = new QuercusClass(this, _stdClassDef, null); _staticClasses.put(_stdClass.getName(), _stdClassDef); }
public Compiler() { _loaders[typeof(TileSet)] = new TileSetLoader(); _loaders[typeof(Map)] = new MapLoader(); _loaders[typeof(Dungeon)] = new DungeonLoader(); _loaders[typeof(TileInfo)] = new TileInfoLoader(); _loaders[typeof(TileObject)] = new TileObjectLoader(); _loaders[typeof(CreatureInfo)] = new CreatureLoader(); _loaders[typeof(BaseItemInfo)] = new ItemLoader(); _loaders[typeof(Class)] = new ClassLoader(); _loaders[typeof(BaseGenerator)] = new GeneratorLoader(); _loaders[typeof(AbilityInfo)] = new AbilityLoader(); }
private static ITreeVisitor LoadTreeVistor(string value) { try { Type c = ClassLoader.GetSystemClassLoader().LoadClass(value); return((ITreeVisitor)System.Activator.CreateInstance(c)); } catch (ReflectiveOperationException e) { Sharpen.Runtime.PrintStackTrace(e); } return(null); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private Callables loadProcedures(java.net.URL jar, ClassLoader loader, Callables target) throws java.io.IOException, org.neo4j.internal.kernel.api.exceptions.KernelException private Callables LoadProcedures(URL jar, ClassLoader loader, Callables target) { RawIterator <Type, IOException> classes = ListClassesIn(jar, loader); while (classes.HasNext()) { Type next = classes.Next(); target.AddAllProcedures(_compiler.compileProcedure(next, null, false)); target.AddAllFunctions(_compiler.compileFunction(next)); target.AddAllAggregationFunctions(_compiler.compileAggregationFunction(next)); } return(target); }
protected internal virtual Schema createSchema(string location, ClassLoader classLoader) { URL cmmnSchema = ReflectUtil.getResource(location, classLoader); try { return(schemaFactory.newSchema(cmmnSchema)); } catch (SAXException) { throw new ModelValidationException("Unable to parse schema:" + cmmnSchema); } }
/// <summary> /// Search the system for given class and return this. /// </summary> /// <param name="className">see System.Type.AssemblyQualifedName</param> /// <param name="cl">ClassLoader - ignored</param> /// <param name="initialize">ignored - ever like true</param> /// <returns></returns> public static Class forName(String className, bool initialize, ClassLoader cl) { //throws ClassNotFoundException { try { System.Type t = System.Type.GetType(className); if (null == t) throw new java.lang.ClassNotFoundException(className); return new Class(t); } catch { throw new java.lang.ClassNotFoundException(className); } }
public void initialize( ) { gxTv_SdtBAS_DataPackage_Datapackage = ""; gxTv_SdtBAS_DataPackage_Mode = ""; gxTv_SdtBAS_DataPackage_Datapackage_Z = ""; IGxSilentTrn obj; obj = (IGxSilentTrn)ClassLoader.FindInstance("bas_datapackage", "GeneXus.Programs.bas_datapackage_bc", new Object[] { context }, constructorCallingAssembly);; obj.initialize(); obj.SetSDT(this, 1); setTransaction(obj); obj.SetMode("INS"); return; }
public void initialize( ) { gxTv_SdtBR_PatientReTenant_Bas_tenanttenantcode = ""; gxTv_SdtBR_PatientReTenant_Mode = ""; gxTv_SdtBR_PatientReTenant_Bas_tenanttenantcode_Z = ""; IGxSilentTrn obj; obj = (IGxSilentTrn)ClassLoader.FindInstance("br_patientretenant", "GeneXus.Programs.br_patientretenant_bc", new Object[] { context }, constructorCallingAssembly);; obj.initialize(); obj.SetSDT(this, 1); setTransaction(obj); obj.SetMode("INS"); return; }
public InformixConnectionWrapper() { try { GXLogging.Debug(log, "Creating Informix data provider "); _connection = (IDbConnection)ClassLoader.CreateInstance(GxInformix.IfxAssembly, "IBM.Data.Informix.IfxConnection"); GXLogging.Debug(log, "Informix data provider created"); } catch (Exception ex) { GXLogging.Error(log, "Informix data provider Ctr error " + ex.Message + ex.StackTrace); throw ex; } }
public void initialize( ) { gxTv_SdtSecFunctionalityRole_Secfunctionalitydescription = ""; gxTv_SdtSecFunctionalityRole_Mode = ""; gxTv_SdtSecFunctionalityRole_Secfunctionalitydescription_Z = ""; IGxSilentTrn obj; obj = (IGxSilentTrn)ClassLoader.FindInstance("secfunctionalityrole", "GeneXus.Programs.wwpbaseobjects.secfunctionalityrole_bc", new Object[] { context }, constructorCallingAssembly);; obj.initialize(); obj.SetSDT(this, 1); setTransaction(obj); obj.SetMode("INS"); return; }
public void initialize( ) { gxTv_SdtSYS_SerialNumber_Serialkey = ""; gxTv_SdtSYS_SerialNumber_Mode = ""; gxTv_SdtSYS_SerialNumber_Serialkey_Z = ""; IGxSilentTrn obj; obj = (IGxSilentTrn)ClassLoader.FindInstance("sys_serialnumber", "GeneXus.Programs.sys_serialnumber_bc", new Object[] { context }, constructorCallingAssembly);; obj.initialize(); obj.SetSDT(this, 1); setTransaction(obj); obj.SetMode("INS"); return; }
public void initialize( ) { gxTv_SdtXT_DefindcodeType_Xt_defindcodetypename = ""; gxTv_SdtXT_DefindcodeType_Mode = ""; gxTv_SdtXT_DefindcodeType_Xt_defindcodetypename_Z = ""; IGxSilentTrn obj; obj = (IGxSilentTrn)ClassLoader.FindInstance("xt_defindcodetype", "GeneXus.Programs.xt_defindcodetype_bc", new Object[] { context }, constructorCallingAssembly);; obj.initialize(); obj.SetSDT(this, 1); setTransaction(obj); obj.SetMode("INS"); return; }
public InformixConnectionWrapper(String connectionString, GxConnectionCache connCache, IsolationLevel isolationLevel) { try { _connection = (IDbConnection)ClassLoader.CreateInstance(GxInformix.IfxAssembly, "IBM.Data.Informix.IfxConnection", new object[] { connectionString }); m_isolationLevel = isolationLevel; m_connectionCache = connCache; } catch (Exception ex) { GXLogging.Error(log, "Informix data provider Ctr error " + ex.Message + ex.StackTrace); throw ex; } }
public PostgresqlConnectionWrapper(String connectionString, GxConnectionCache connCache, IsolationLevel isolationLevel) { try { _connection = (IDbConnection)ClassLoader.CreateInstance(GxPostgreSql.NpgsqlAssembly, "Npgsql.NpgsqlConnection", new object[] { connectionString }); m_isolationLevel = isolationLevel; m_connectionCache = connCache; } catch (Exception ex) { GXLogging.Error(log, "Npgsql data provider Ctr error " + ex.Message + ex.StackTrace); throw ex; } }
public void initialize( ) { gxTv_SdtBR_Pathology_Specimen_Br_pathology_specimen_name = ""; gxTv_SdtBR_Pathology_Specimen_Mode = ""; gxTv_SdtBR_Pathology_Specimen_Br_pathology_specimen_name_Z = ""; IGxSilentTrn obj; obj = (IGxSilentTrn)ClassLoader.FindInstance("br_pathology_specimen", "GeneXus.Programs.br_pathology_specimen_bc", new Object[] { context }, constructorCallingAssembly);; obj.initialize(); obj.SetSDT(this, 1); setTransaction(obj); obj.SetMode("INS"); return; }
public override void RestoreState(IParcelable state, ClassLoader loader) { Bundle bundle = (Bundle)state; int pages = bundle.GetInt(_statePages); if (0 < pages) { for (int i = 0; i < pages; i++) { int position = bundle.GetInt(CreateCacheIndex(i)); Fragment f = _fm.GetFragment(bundle, CreateCacheKey(position)); _pages.Put(position, f); } } IParcelable p = (IParcelable)bundle.GetParcelable(_stateSuperState); base.RestoreState(p, loader); }
//UPGRADE_ISSUE: Class 'java.lang.ClassLoader' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javalangClassLoader"' /// <summary> Creates an instance of an AudioDevice implementation. /// </summary> /// <param name="loader The"><code>ClassLoader</code> to use to /// load the named class, or null to use the /// system class loader. /// </param> /// <param name="name The">name of the class to load. /// </param> /// <returns> A newly-created instance of the audio device class. /// /// </returns> protected internal virtual AudioDevice instantiate(ClassLoader loader, System.String name) { AudioDevice dev = null; System.Type cls = null; if (loader == null) { //UPGRADE_TODO: Format of parameters of method 'java.lang.Class.forName' are different in the equivalent in .NET. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1092"' cls = System.Type.GetType(name); } else { //UPGRADE_ISSUE: Method 'java.lang.ClassLoader.loadClass' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javalangClassLoader"' cls = loader.loadClass(name); } System.Object o = SupportClass.CreateNewInstance(cls); dev = (AudioDevice) o; return dev; }
// // get class path // static ClassLoaderUtil() { if (loader == null) { LOGGER.info("using system class loader!"); loader = ClassLoader.SystemClassLoader; } try { URL url = loader.getResource(""); // get class path classPath = url.Path; classPath = URLDecoder.decode(classPath, "utf-8"); // 如果是jar包内的,则返回当前路径 if (classPath.Contains(".jar!")) { LOGGER.warn("using config file inline jar!" + classPath); classPath = System.getProperty("user.dir"); // addCurrentWorkingDir2Classpath(classPath); } } catch (Exception) { LOGGER.warn("cannot get classpath using getResource(), now using user.dir"); classPath = System.getProperty("user.dir"); // addCurrentWorkingDir2Classpath(classPath); } LOGGER.info("classpath: {}", classPath); }
/// <summary>Attempt to load the class of the given name.</summary> /// <remarks> /// Attempt to load the class of the given name. Note that the type parameter /// isn't checked. /// </remarks> public static Type ClassOrNull(ClassLoader loader, string className) { try { return loader.LoadClass(className); } catch (TypeLoadException) { } catch (SecurityException) { } catch (LinkageError) { } catch (ArgumentException) { } // Can be thrown if name has characters that a class name // can not contain return null; }
public _ObjectInputStream_1358(ClassLoader loader, InputStream baseArg1) : base(baseArg1 ) { this.loader = loader; }
/// <summary> /// Attempts to decode Base64 data and deserialize a Java /// Object within. /// </summary> /// <remarks> /// Attempts to decode Base64 data and deserialize a Java /// Object within. Returns <tt>null</tt> if there was an error. /// If <tt>loader</tt> is not null, it will be the class loader /// used when deserializing. /// </remarks> /// <param name="encodedObject">The Base64 data to decode</param> /// <param name="options">Various parameters related to decoding</param> /// <param name="loader">Optional class loader to use in deserializing classes.</param> /// <returns>The decoded and deserialized object</returns> /// <exception cref="System.ArgumentNullException">if encodedObject is null</exception> /// <exception cref="System.IO.IOException">if there is a general error</exception> /// <exception cref="System.TypeLoadException"> /// if the decoded object is of a /// class that cannot be found by the JVM /// </exception> /// <since>2.3.4</since> public static object DecodeToObject(string encodedObject, int options, ClassLoader loader) { // Decode and gunzip if necessary byte[] objBytes = Decode(encodedObject, options); ByteArrayInputStream bais = null; ObjectInputStream ois = null; object obj = null; try { bais = new ByteArrayInputStream(objBytes); // If no custom class loader is provided, use Java's builtin OIS. if (loader == null) { ois = new ObjectInputStream(bais); } else { // end if: no loader provided // Else make a customized object input stream that uses // the provided class loader. ois = new _ObjectInputStream_1358(loader, bais); } // Class loader knows of this class. // end else: not null // end resolveClass // end ois // end else: no custom class loader obj = ois.ReadObject(); } catch (IOException e) { // end try throw; } catch (TypeLoadException e) { // Catch and throw in order to execute finally{} // end catch throw; } finally { // Catch and throw in order to execute finally{} // end catch try { bais.Close(); } catch (Exception) { } try { ois.Close(); } catch (Exception) { } } // end finally return obj; }
/// <exception cref="System.MissingMethodException"></exception> /// <exception cref="Sharpen.InstantiationException"></exception> /// <exception cref="System.MemberAccessException"></exception> /// <exception cref="System.Reflection.TargetInvocationException"></exception> private static ShellConsole.JLineShellConsoleV2 GetJLineShellConsoleV2(ClassLoader classLoader, Type readerClass, Scriptable scope, Encoding cs) { // ConsoleReader reader = new ConsoleReader(); ConstructorInfo<object> c = readerClass.GetConstructor(); object reader = c.NewInstance(); // reader.setBellEnabled(false); TryInvoke(reader, "setBellEnabled", BOOLEAN_ARG, false); // reader.addCompleter(new FlexibleCompletor(prefixes)); Type completorClass = Kit.ClassOrNull(classLoader, "jline.console.completer.Completer"); object completor = Proxy.NewProxyInstance(classLoader, new Type[] { completorClass }, new FlexibleCompletor(completorClass, scope)); TryInvoke(reader, "addCompleter", new Type[] { completorClass }, completor); return new ShellConsole.JLineShellConsoleV2(reader, cs); }
/** * Resets this Uberspect class loader. * @param cloader the class loader to use * @since 2.1 */ public void setLoader(ClassLoader cloader) { base().setLoader(cloader); }
/// <summary>Create class loader for generated classes.</summary> /// <remarks> /// Create class loader for generated classes. /// The method calls /// <see cref="ContextFactory.CreateClassLoader(Sharpen.ClassLoader)">ContextFactory.CreateClassLoader(Sharpen.ClassLoader)</see> /// using the result of /// <see cref="GetFactory()">GetFactory()</see> /// . /// </remarks> public virtual GeneratedClassLoader CreateClassLoader(ClassLoader parent) { ContextFactory f = GetFactory(); return f.CreateClassLoader(parent); }
public NativeJavaPackage(string packageName, ClassLoader classLoader) : this(false, packageName, classLoader) { }
public static MethodType fromMethodDescriptorString(String arg0, ClassLoader arg1) { return Static.CallMethod<MethodType>(typeof(MethodType), "fromMethodDescriptorString", "(Ljava/lang/String;Ljava/lang/ClassLoader;)Ljava/lang/invoke/MethodType;", arg0, arg1); }
public void SetApplicationClassLoader(ClassLoader loader) { if (@sealed) { OnSealedMutation(); } if (loader == null) { // restore default behaviour applicationClassLoader = null; return; } if (!Kit.TestIfCanLoadRhinoClasses(loader)) { throw new ArgumentException("Loader can not resolve Rhino classes"); } applicationClassLoader = loader; }
public override void RestoreState (Android.OS.IParcelable state, ClassLoader loader) { }
// Z:\jsc.svn\core\ScriptCoreLibJava\BCLImplementation\System\ServiceModel\ClientBase.cs public static object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler invocationHandler) { return null; }
public DefiningClassLoader(ClassLoader parentLoader) { this.parentLoader = parentLoader; }
/// <summary> /// Create /// <see cref="GeneratedClassLoader">GeneratedClassLoader</see> /// with restrictions imposed by /// staticDomain and all current stack frames. /// The method uses the SecurityController instance associated with the /// current /// <see cref="Context">Context</see> /// to construct proper dynamic domain and create /// corresponding class loader. /// <par> /// If no SecurityController is associated with the current /// <see cref="Context">Context</see> /// , /// the method calls /// <see cref="Context.CreateClassLoader(Sharpen.ClassLoader)">Context.CreateClassLoader(Sharpen.ClassLoader)</see> /// . /// </summary> /// <param name="parent"> /// parent class loader. If null, /// <see cref="Context.GetApplicationClassLoader()">Context.GetApplicationClassLoader()</see> /// will be used. /// </param> /// <param name="staticDomain">static security domain.</param> public static GeneratedClassLoader CreateLoader(ClassLoader parent, object staticDomain) { Context cx = Context.GetContext(); if (parent == null) { parent = cx.GetApplicationClassLoader(); } SecurityController sc = cx.GetSecurityController(); GeneratedClassLoader loader; if (sc == null) { loader = cx.CreateClassLoader(parent); } else { object dynamicDomain = sc.GetDynamicSecurityDomain(staticDomain); loader = sc.CreateClassLoader(parent, dynamicDomain); } return loader; }
/// <summary> /// Set the context class loader /// </summary> /// <param name="cl"></param> public void setContextClassLoader(ClassLoader cl) { if (null == cl) throw new NullPointerException("Classloader can not be null"); this.contextClassLoader = cl; }
public override void RestoreState(IParcelable state, ClassLoader loader) { if (state == null) return; var bundle = (Bundle)state; bundle.SetClassLoader(loader); var fss = bundle.GetParcelableArray("states"); _savedState.Clear(); _fragments.Clear(); var tags = bundle.GetStringArrayList("tags"); if (tags != null) _savedFragmentTags = tags.ToList(); else _savedFragmentTags.Clear(); if (fss != null) { for (var i = 0; i < fss.Length; i++) { var parcelable = fss.ElementAt(i); var savedState = parcelable.JavaCast<Fragment.SavedState>(); _savedState.Add(savedState); } } var keys = bundle.KeySet(); foreach (var key in keys) { if (!key.StartsWith("f")) continue; var index = Integer.ParseInt(key.Substring(1)); if (_fragmentManager.Fragments == null) return; var f = _fragmentManager.GetFragment(bundle, key); if (f != null) { while (_fragments.Count() <= index) _fragments.Add(null); f.SetMenuVisibility(false); _fragments[index] = f; } } }
/// <summary> /// The disconnect. /// </summary> /// <param name="context"> /// The context. /// </param> public void Disconnect(Context context) { if (this.isBound) { context.UnbindService(this.serviceConnection); this.isBound = false; } this.classLoader = null; }
public override void RestoreState (IParcelable state, ClassLoader loader) { //Don't call restore to prevent crash on rotation //base.RestoreState (state, loader); }
/// <summary> /// Reloads the factory list from the given <seealso cref="ClassLoader"/>. /// Changes to the factories are visible after the method ends, all /// iterators (<seealso cref="#availableTokenizers()"/>,...) stay consistent. /// /// <para><b>NOTE:</b> Only new factories are added, existing ones are /// never removed or replaced. /// /// </para> /// <para><em>This method is expensive and should only be called for discovery /// of new factories on the given classpath/classloader!</em> /// </para> /// </summary> public static void ReloadTokenizers(ClassLoader classloader) { loader.reload(classloader); }
/// <summary> /// Get class loader-like object that can be used /// to define classes with the given security context. /// </summary> /// <remarks> /// Get class loader-like object that can be used /// to define classes with the given security context. /// </remarks> /// <param name="parentLoader"> /// parent class loader to delegate search for classes /// not defined by the class loader itself /// </param> /// <param name="securityDomain"> /// some object specifying the security /// context of the code that is defined by the returned class loader. /// </param> public abstract GeneratedClassLoader CreateClassLoader(ClassLoader parentLoader, object securityDomain);
/// <summary> /// Reloads the factory list from the given <seealso cref="ClassLoader"/>. /// Changes to the factories are visible after the method ends, all /// iterators (<seealso cref="#availableCharFilters()"/>,...) stay consistent. /// /// <para><b>NOTE:</b> Only new factories are added, existing ones are /// never removed or replaced. /// /// </para> /// <para><em>This method is expensive and should only be called for discovery /// of new factories on the given classpath/classloader!</em> /// </para> /// </summary> public static void reloadCharFilters(ClassLoader classloader) { loader.reload(classloader); }
/// <summary>Check that testClass is accessible from the given loader.</summary> /// <remarks>Check that testClass is accessible from the given loader.</remarks> internal static bool TestIfCanLoadRhinoClasses(ClassLoader loader) { Type testClass = ScriptRuntime.ContextFactoryClass; Type x = Kit.ClassOrNull(loader, testClass.FullName); if (x != testClass) { // The check covers the case when x == null => // loader does not know about testClass or the case // when x != null && x != testClass => // loader loads a class unrelated to testClass return false; } return true; }
internal NativeJavaTopPackage(ClassLoader loader) : base(true, string.Empty, loader) { }
/// <summary> /// Return the System ClassLoader /// </summary> /// <returns></returns> public ClassLoader getContextClassLoader() { if (null == contextClassLoader) { this.contextClassLoader = ClassLoader.getSystemClassLoader(); } return this.contextClassLoader; }
internal NativeJavaPackage(bool internalUsage, string packageName, ClassLoader classLoader) { this.packageName = packageName; this.classLoader = classLoader; }