Sets all members, types and executables in this module as public as
        long as it doesn't already have the 'private' modifier.
13524
def all_to_public(self):
        
        if "private" not in self.modifiers:
            def public_collection(attribute):
                for key in self.collection(attribute):
                    if key not in self.publics:
                        self.publics[key.lower()] = 1
            public_collection("members")
            public_collection("types")
            public_collection("executables")
364965
private function setByTypeModule(string $module, array $fields) : void
    {
        foreach ($fields as $field) {
            $this->setByTypeModuleField($module, $field);
        }
    }
444815
public void setType(int type) {
        this.type = type;
        if (level == LEVEL_UNDEFINED) {
            switch (type) {
                case TYPE_INT:
                case TYPE_LONG:
                case TYPE_DOUBLE:
                    level = LEVEL_LOW;
                    break;
                case TYPE_STAT:
                    level = LEVEL_MEDIUM;
                    unit = "unit.ms";
                    break;
                case TYPE_LOAD:
                    level = LEVEL_HIGH;
                    break;
                case TYPE_SUBMODULE:
                    level = LEVEL_MAX;
                    break;
                default:
                    break;
            }
        }
    }
825620
public final <T1 extends SourceFile, T2 extends SourceFile> void init(
      List<T1> externs, List<T2> sources, CompilerOptions options) {
    JSModule module = new JSModule(JSModule.STRONG_MODULE_NAME);
    for (SourceFile source : sources) {
      module.add(new CompilerInput(source));
    }

    List<JSModule> modules = new ArrayList<>(1);
    modules.add(module);
    initModules(externs, modules, options);
    addFilesToSourceMap(sources);
  }
917478
def public_set(option, value)
      # TODO Prevent subconfigs here
      method = "#{option}="
      respond_to?(method) ? send(method, value) : raw_set(option, value)
    end
1315726
def add_to_public_members(self, public_member):
        
        assert isinstance(public_member, github.NamedUser.NamedUser), public_member
        headers, data = self._requester.requestJsonAndCheck(
            "PUT",
            self.url + "/public_members/" + public_member._identity
        )
187530
def register_all(module, exclude=[], AdminClass=admin.ModelAdmin):
    
    member_names = dir(module)

    for member_name in member_names:
        obj = getattr(module, member_name, None)
        if isinstance(obj, ModelBase) \
            and obj not in exclude \
            and not obj._meta.abstract:
            try:
                if hasattr(obj, 'localized_fields'):
                    admin.site.register(obj, L10n(obj, AdminClass))
                else:
                    admin.site.register(obj, AdminClass)
            except AlreadyRegistered:
                pass
516960
def _process_type(self, name, modifiers, contents, module, match):
        """"""
        #First, we need to see if the types children are private.
        if self.RE_PRIV.search(contents):
            modifiers.append("private contents")

        #Next, we need to parse out all the members of the type and their docstrings
        members = self.vparser.parse(contents, None)
        
        #Now we can create the type code element and handle the member docstrings
        t = CustomType(name, modifiers, members, module)
        #parse out all the executables including the finalizer
        execs = self._process_execs(contents, module.name, t)

        #Set the regex start and end char indices
        t.start, t.end = module.absolute_charindex(match.string, match.start(),
                                                             match.end())

        #Update the parent for embedded members and executables
        for key in list(t.members.keys()):
            t.members[key].parent = t
        for key in list(t.executables.keys()):
            t.executables[key].parent = t

        #Extract the docstrings from the type body and associate them with their members
        memdocs = self.docparser.parse_docs(contents, t)
        if name in memdocs:
            docs = self.docparser.to_doc(memdocs[name][0], name)
            self.docparser.process_memberdocs(docs, t)

        return t
1335628
def has_public_assign(class_):
    """"""
    class_ = class_traits.get_declaration(class_)
    decls = class_.member_operators(
        lambda o: o.symbol == '=' and o.access_type == 'public',
        recursive=False,
        allow_empty=True)
    return bool(decls)
430777
def setTypesModuleName(self, name, modulePath=None):
        
        self.typesModuleName = '%s' %name
        if modulePath is not None:
            self.typesModuleName = '%s.%s' %(modulePath,name)
409925
def persistent_modprobe(module):
    """"""
    with open('/etc/modules', 'r+') as modules:
        if module not in modules.read():
            modules.write(module + "\n")
567364
def should_show(options, member):
    

    show = options.show
    if show == SHOW_PUBLIC:
        return member.is_public()
    elif show == SHOW_PACKAGE:
        return member.is_public() or member.is_protected()
    elif show == SHOW_PRIVATE:
        return True
1134455
def initialize_public_method(method, parent)
      return if !method || !parent

      new_meth = AnyMethod.new("External Alias for module", method.name)
      new_meth.singleton    = method.singleton
      new_meth.params       = method.params.clone
      new_meth.comment      = remove_trailing_alias(method.comment.clone)
      new_meth.comment      << "\n\n#{EXTERNAL_ALIAS_MES} #{parent.strip.chomp}\##{method.name}"

      return new_meth
    end
348791
boolean isPackagePrivate(Element element) {
        Set<Modifier> modifiers = element.getModifiers();
        return !(modifiers.contains(PUBLIC)
            || modifiers.contains(PROTECTED)
            || modifiers.contains(PRIVATE));
    }
704021
def _set_persistent_module(mod):
    '''
    
    '''
    if not mod or mod in mod_list(True) or mod not in \
            available():
        return set()
    __salt__['file.append'](_LOADER_CONF, _LOAD_MODULE.format(mod))
    return set([mod])
401785
def __public_objs(self):
        
        members = dict(inspect.getmembers(self.module))
        return dict([(name, obj)
                     for name, obj in members.items()
                     if self.__is_exported(name, inspect.getmodule(obj))])
169634
public function setModule($value) {
		if (is_object($value)) {
			$this->module = get_class($value);
		}else {
			$this->module = (string) $value;
		}
	}