internal void InitializeMembersFrom(RubyModule/*!*/ module) { Context.RequiresClassHierarchyLock(); Mutate(); Assert.NotNull(module); #if !SILVERLIGHT // missing Clone on Delegate if (module._namespaceTracker != null && _constants == null) { #endif // initialize the module so that we can copy all constants from it: module.InitializeConstantsNoLock(); // initialize all ancestors of self: InitializeConstantsNoLock(); #if !SILVERLIGHT } else { _constantsInitializer = (module._constantsInitializer != null) ? (Action<RubyModule>)module._constantsInitializer.Clone() : null; _constantsState = module._constantsState; } #endif _constants = (module._constants != null) ? new Dictionary<string, ConstantStorage>(module._constants) : null; // copy namespace members: if (module._namespaceTracker != null) { Debug.Assert(_constants != null); foreach (KeyValuePair<SymbolId, object> constant in module._namespaceTracker.SymbolAttributes) { _constants.Add(SymbolTable.IdToString(constant.Key), new ConstantStorage(constant.Value)); } } #if SILVERLIGHT module.InitializeMethodsNoLock(); InitializeMethodsNoLock(); #else _methodsInitializer = (module._methodsInitializer != null) ? (Action<RubyModule>)module._methodsInitializer.Clone() : null; _methodsState = module._methodsState; #endif _methods = (module._methods != null) ? new Dictionary<string, RubyMemberInfo>(module._methods) : null; _classVariables = (module._classVariables != null) ? new Dictionary<string, object>(module._classVariables) : null; _mixins = ArrayUtils.Copy(module._mixins); // dependentModules - skip // tracker - skip, .NET members not copied // TODO: // - handle overloads cached in groups // - version updates MethodsUpdated("InitializeFrom"); }
private void InitializeMethodTableNoLock() { if (!MethodInitializationNeeded) return; InitializeDependencies(); _methods = new Dictionary<string, RubyMemberInfo>(); _methodsState = MemberTableState.Initializing; try { if (_methodsInitializer != null) { Utils.Log(_name ?? "<anonymous>", "MT_INIT"); // TODO: use lock-free operations in initializers? _methodsInitializer(this); } } finally { _methodsInitializer = null; _methodsState = MemberTableState.Initialized; } }
private void InitializeConstantTableNoLock() { if (!ConstantInitializationNeeded) return; _constants = new Dictionary<string, ConstantStorage>(); _constantsState = MemberTableState.Initializing; try { if (_constantsInitializer != EmptyInitializer) { if (_constantsInitializer != null) { Utils.Log(_name ?? "<anonymous>", "CT_INIT"); // TODO: use lock-free operations in initializers _constantsInitializer(this); } else if (!IsInterface && _typeTracker != null) { // Load types eagerly. We do this only for CLR types that have no constant initializer (not builtins) and // a constant access is performed (otherwise this method wouldn't be called). // // Note: Interfaces cannot declare nested types in C#, we follow the suit here. // We don't currently need this restriction but once we implement generic type overload inheritance properly // we would need to deal with inheritance from interfaces, which might be too complex. // LoadNestedTypes(); } } } finally { _constantsInitializer = null; _constantsState = MemberTableState.Initialized; } }
private void IncludeTraitNoLock(ref Action<RubyModule> initializer, MemberTableState tableState, Action<RubyModule>/*!*/ trait) { Assert.NotNull(trait); if (tableState == MemberTableState.Uninitialized) { if (initializer != null) { initializer += trait; } else { initializer = trait; } } else { // TODO: postpone? hold lock? using (Context.ClassHierarchyUnlocker()) { trait(this); } } }
private void InitializeConstantTableNoLock() { if (!ConstantInitializationNeeded) return; if (!DeclaresGlobalConstants) { _constants = new Dictionary<string, object>(); } _constantsState = MemberTableState.Initializing; try { if (_constantsInitializer != null) { Utils.Log(_name ?? "<anonymous>", "CT_INIT"); // TODO: use lock-free operations in initializers _constantsInitializer(this); } } finally { _constantsInitializer = null; _constantsState = MemberTableState.Initialized; } }
internal void InitializeMembersFrom(RubyModule/*!*/ module) { Context.RequiresClassHierarchyLock(); Mutate(); Assert.NotNull(module); if (module._namespaceTracker != null && _constants == null) { // initialize the module so that we can copy all constants from it: module.InitializeConstantsNoLock(); // initialize all ancestors of self: InitializeConstantsNoLock(); } else { _constantsInitializer = Utils.CloneInvocationChain(module._constantsInitializer); _constantsState = module._constantsState; } _constants = (module._constants != null) ? new Dictionary<string, ConstantStorage>(module._constants) : null; // copy namespace members: if (module._namespaceTracker != null) { Debug.Assert(_constants != null); foreach (KeyValuePair<string, object> constant in module._namespaceTracker) { _constants.Add(constant.Key, new ConstantStorage(constant.Value)); } } _methodsInitializer = Utils.CloneInvocationChain(module._methodsInitializer); _methodsState = module._methodsState; if (module._methods != null) { _methods = new Dictionary<string, RubyMemberInfo>(module._methods.Count); foreach (var method in module._methods) { _methods[method.Key] = method.Value.Copy(method.Value.Flags, this); } } else { _methods = null; } _classVariables = (module._classVariables != null) ? new Dictionary<string, object>(module._classVariables) : null; _mixins = ArrayUtils.Copy(module._mixins); // dependentModules - skip // tracker - skip, .NET members not copied // TODO: // - handle overloads cached in groups // - version updates MethodsUpdated("InitializeFrom"); }