|
public GetOrCreateSingletonClass ( ) : |
||
| return | ||
public static object Included(RubyContext/*!*/ context, RubyModule/*!*/ self, RubyModule/*!*/ includedIn) {
var singleton = includedIn.GetOrCreateSingletonClass();
singleton.AddMethod(
context,
"induced_from",
new RubyLibraryMethodInfo(
new[] { LibraryOverload.Create(new Func<RubyModule, object, object>(InducedFrom), false, 0, 0) },
RubyMethodVisibility.Public,
singleton
)
);
return self;
}
internal static void SetMethodAttributes(RubyModule /*!*/ module, string /*!*/[] /*!*/ methodNames, RubyMethodAttributes attributes)
{
var context = module.Context;
bool isModuleFunction = (attributes & RubyMethodAttributes.ModuleFunction) == RubyMethodAttributes.ModuleFunction;
var instanceVisibility = isModuleFunction ? RubyMethodVisibility.Private :
(RubyMethodVisibility)(attributes & RubyMethodAttributes.VisibilityMask);
foreach (string methodName in methodNames)
{
RubyMemberInfo method;
// we need to define new methods one by one since the method_added events can define a new method that might be used here:
using (context.ClassHierarchyLocker()) {
MethodLookup options = MethodLookup.FallbackToObject;
if (!isModuleFunction)
{
options |= MethodLookup.ReturnForwarder;
}
method = module.ResolveMethodNoLock(methodName, VisibilityContext.AllVisible, options).Info;
if (method == null)
{
throw RubyExceptions.CreateUndefinedMethodError(module, methodName);
}
// MRI only adds method to the target module if visibility differs:
if (method.Visibility != instanceVisibility)
{
module.SetVisibilityNoEventNoLock(context, methodName, method, instanceVisibility);
}
if (isModuleFunction)
{
module.SetModuleFunctionNoEventNoLock(context, methodName, method);
}
}
if (method.Visibility != instanceVisibility)
{
module.MethodAdded(methodName);
}
if (isModuleFunction)
{
module.GetOrCreateSingletonClass().MethodAdded(methodName);
}
}
}
public static object Included(RubyContext /*!*/ context, RubyModule /*!*/ self, RubyModule /*!*/ includedIn)
{
var singleton = includedIn.GetOrCreateSingletonClass();
singleton.AddMethod(
context,
"induced_from",
new RubyLibraryMethodInfo(
new[] { LibraryOverload.Create(new Func <RubyModule, object, object>(InducedFrom), false, 0, 0) },
RubyMethodVisibility.Public,
singleton
)
);
return(self);
}
public static RubyModule /*!*/ MakeClassMethodsPublic(RubyModule /*!*/ self,
[DefaultProtocol, NotNullItems] params string /*!*/[] /*!*/ methodNames)
{
SetMethodAttributes(self.GetOrCreateSingletonClass(), methodNames, RubyMethodAttributes.Public);
return(self);
}
object IDuplicable.Duplicate(RubyContext/*!*/ context, bool copySingletonMembers) {
// capture the current immediate class (it can change any time if it not a singleton class)
RubyClass immediate = _immediateClass;
RubyModule result = new RubyModule(immediate.IsSingletonClass ? immediate.SuperClass : immediate, null);
// singleton members are copied here, not in InitializeCopy:
if (copySingletonMembers && immediate.IsSingletonClass) {
var singletonClass = result.GetOrCreateSingletonClass();
using (Context.ClassHierarchyLocker()) {
singletonClass.InitializeMembersFrom(immediate);
}
}
// copy instance variables:
_context.CopyInstanceData(this, result, false);
return result;
}
internal static void SetMethodAttributes(RubyModule/*!*/ module, string/*!*/[]/*!*/ methodNames, RubyMethodAttributes attributes) {
var context = module.Context;
bool isModuleFunction = (attributes & RubyMethodAttributes.ModuleFunction) == RubyMethodAttributes.ModuleFunction;
var instanceVisibility = isModuleFunction ? RubyMethodVisibility.Private :
(RubyMethodVisibility)(attributes & RubyMethodAttributes.VisibilityMask);
foreach (string methodName in methodNames) {
RubyMemberInfo method;
// we need to define new methods one by one since the method_added events can define a new method that might be used here:
using (context.ClassHierarchyLocker()) {
MethodLookup options = MethodLookup.FallbackToObject;
if (!isModuleFunction) {
options |= MethodLookup.ReturnForwarder;
}
method = module.ResolveMethodNoLock(methodName, VisibilityContext.AllVisible, options).Info;
if (method == null) {
throw RubyExceptions.CreateUndefinedMethodError(module, methodName);
}
// MRI only adds method to the target module if visibility differs:
if (method.Visibility != instanceVisibility) {
module.SetVisibilityNoEventNoLock(context, methodName, method, instanceVisibility);
}
if (isModuleFunction) {
module.SetModuleFunctionNoEventNoLock(context, methodName, method);
}
}
if (method.Visibility != instanceVisibility) {
module.MethodAdded(methodName);
}
if (isModuleFunction) {
module.GetOrCreateSingletonClass().MethodAdded(methodName);
}
}
}
public static RubyModule/*!*/ MakeClassMethodsPublic(RubyModule/*!*/ self,
[DefaultProtocol, NotNullItems]params string/*!*/[]/*!*/ methodNames) {
SetMethodAttributes(self.GetOrCreateSingletonClass(), methodNames, RubyMethodAttributes.Public);
return self;
}