Returns all public imports in this proto file.
779680
public List<Import> getPublicImports() {
        return getImports()
                .stream()
                .filter(Import::isPublic)
                .collect(Collectors.toList());
    }
505813
def get_all_methods(self, entry_point=ALL, protocol=ALL, sort_methods=False):
        """"""

        if sort_methods:
            return [
                method for (_, method) in sorted(self._registry.items()) if method.is_valid_for(entry_point, protocol)
            ]

        return self._registry.values()
680202
def getAllPlatformObjects(mode = None):
    

    listAll = []

    ############################################################################
    ############################################################################

    # --------------------------------------------------------------------------
    # Dinamically collecting all the "official" modules
    # --------------------------------------------------------------------------

    # A list that will contain all of the module names
    all_modules = []

    # Grabbing all the module names
    for _, name, _ in pkgutil.iter_modules(osrframework.wrappers.__path__):
        all_modules.append("osrframework.wrappers." + name)

    # Iterating through all the module names to grab them
    for moduleName in all_modules:
        # Importing the module
        my_module = importlib.import_module(moduleName)

        # Getting all the classNames.
        classNames = [m[0] for m in inspect.getmembers(my_module, inspect.isclass) if m[1].__module__ == moduleName]

        # Dinamically grabbing the first class of the module. IT SHOULD BE ALONE!
        MyClass = getattr(my_module, classNames[0])

        # Instantiating the object
        newInstance = MyClass()

        # Adding to the list!
        listAll.append(newInstance)

    # --------------------------------------------------------------------------
    # Loading user-defined wrappers under [OSRFrameworkHOME]/plugins/wrappers/
    # --------------------------------------------------------------------------

    # Creating the application paths
    paths = configuration.getConfigPath()

    newPath = os.path.abspath(paths["appPathWrappers"])

    # Inserting in the System Path
    if not newPath in sys.path:
        sys.path.append(newPath)

    userImportedModules = {}

    for module in os.listdir(newPath):
        if module[-3:] == '.py':
            current = module.replace('.py', '')
            userImportedModules[current] = __import__(current)

    del newPath

    userClasses = []

    # Iterating through all the files
    for userModule in userImportedModules.keys():

        my_module = userImportedModules[userModule]
        # Getting all the classNames.
        classNames = [m[0] for m in inspect.getmembers(my_module, inspect.isclass) if m[1].__module__ == userModule]

        # Dinamically grabbing the first class of the module. IT SHOULD BE ALONE!
        MyClass = getattr(my_module, classNames[0])

        # Instantiating the object
        newInstance = MyClass()

        # Adding to the list!
        userClasses.append(newInstance)

    # --------------------------------------------------------------------------
    # Overwriting original modules with the user plugins
    # --------------------------------------------------------------------------
    listToAdd = []
    for userClass in userClasses:
        overwritten = False
        for i, officialClass in enumerate(listAll):
            # Checking if the name is the same
            if str(userClass) == str(officialClass):
                # Replacing the official module if a user module exists for it
                listAll[i] = userClass
                # We stop iterating this loop
                overwritten = True
                break
        if not overwritten:
            # Appending the new class
            listToAdd.append(userClass)

    # Merging listAll and listToAdd
    listAll = listAll + listToAdd
    ############################################################################
    ############################################################################

    creds = credentials.getCredentials()

    for p in listAll:
        # Verify if there are credentials to be loaded
        if p.platformName.lower() in creds.keys():
            p.setCredentials(creds[p.platformName.lower()])

    if mode == None:
        return listAll
    else:
        # We are returning only those platforms which are required by the mode.
        selected = []
        for p in listAll:
            try:
                if p.isValidMode[mode]:
                    selected.append(p)
            except:
                pass
        return selected
844538
protected Proto searchFromProtoPathAndClasspath(String path, Proto importer)
            throws Exception
    {
        // proto_path
        File protoFile;
        for (File dir : __protoLoadDirs)
        {
            if ((protoFile = new File(dir, path)).exists())
                return loadFrom(protoFile, importer);
        }

        // classpath
        Proto protoFromOtherResource = loadFromOtherResource(path, importer);
        if (protoFromOtherResource == null)
        {
            throw new IllegalStateException("Imported proto " + path +
                    " not found. (" + importer.getSourcePath() + ")");
        }

        return protoFromOtherResource;
    }
263307
public static ImportSet getASBoxImports (Class<?> clazz)
    {
        ImportSet imports = new ImportSet();
        boxASArgumentAndGatherImports(clazz, "foo", imports);
        return imports;
    }
1263462
@PublicAPI(usage = ACCESS)
    public JavaClasses importClasspath() {
        return importClasspath(new ImportOptions().with(ImportOption.Predefined.DO_NOT_INCLUDE_ARCHIVES));
    }
732442
public function getPublicResourcePaths()
    {
        $paths = [];
        foreach ($this->packageManager->getFlowPackages() as $packageKey => $package) {
            $publicResourcesPath = Files::concatenatePaths([$package->getResourcesPath(), 'Public']);
            if (is_dir($publicResourcesPath)) {
                $paths[$packageKey] = $publicResourcesPath;
            }
        }
        return $paths;
    }
511798
public List<PortletType<PortletAppType<T>>> getAllPortlet()
   {
      List<PortletType<PortletAppType<T>>> list = new ArrayList<PortletType<PortletAppType<T>>>();
      List<Node> nodeList = childNode.get("portlet");
      for(Node node: nodeList)
      {
         PortletType<PortletAppType<T>>  type = new PortletTypeImpl<PortletAppType<T>>(this, "portlet", childNode, node);
         list.add(type);
      }
      return list;
   }
1263347
public List<PortletType<PortletDescriptor>> getAllPortlet()
   {
      List<PortletType<PortletDescriptor>> list = new ArrayList<PortletType<PortletDescriptor>>();
      List<Node> nodeList = model.get("portlet");
      for(Node node: nodeList)
      {
         PortletType<PortletDescriptor>  type = new PortletTypeImpl<PortletDescriptor>(this, "portlet", model, node);
         list.add(type);
      }
      return list;
   }
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")
1283926
def find_imports(filename):
    
    with open(filename) as f:
        root = ast.parse(f.read(), filename)
    visitor = ImportFinder(filename)
    visitor.visit(root)
    return visitor.imports
1018829
private Stream<ImportSnippet> importSnippets() {
        return state.keyMap.importKeys()
                .map(key -> (ImportSnippet)getSnippet(key))
                .filter(sn -> sn != null && state.status(sn).isDefined());
    }
1111548
public java.util.List<Export> getExports() {
        if (exports == null) {
            exports = new com.amazonaws.internal.SdkInternalList<Export>();
        }
        return exports;
    }
12039
private static ImmutableList<ImportTree> getWildcardImports(List<? extends ImportTree> imports) {
    ImmutableList.Builder<ImportTree> result = ImmutableList.builder();
    for (ImportTree tree : imports) {
      // javac represents on-demand imports as a member select where the selected name is '*'.
      Tree ident = tree.getQualifiedIdentifier();
      if (!(ident instanceof MemberSelectTree)) {
        continue;
      }
      MemberSelectTree select = (MemberSelectTree) ident;
      if (select.getIdentifier().contentEquals("*")) {
        result.add(tree);
      }
    }
    return result.build();
  }
575183
function importSupportObjects() {

    // import shared objects from multiple paths (after global vars have been created)
    if (global.sharedObjectPaths && Array.isArray(global.sharedObjectPaths) && global.sharedObjectPaths.length > 0) {

        var allDirs = {};

        // first require directories into objects by directory
        global.sharedObjectPaths.forEach(function (itemPath) {

            if (fs.existsSync(itemPath)) {

                var dir = requireDir(itemPath, { camelcase: true, recurse: true });

                merge(allDirs, dir);
            }
        });

        // if we managed to import some directories, expose them
        if (Object.keys(allDirs).length > 0) {

            // expose globally
            global.shared = allDirs;
        }
    }

    // import page objects (after global vars have been created)
    if (global.pageObjectPath && fs.existsSync(global.pageObjectPath)) {

        // require all page objects using camel case as object names
        global.page = requireDir(global.pageObjectPath, { camelcase: true, recurse: true });
    }

    // add helpers
    global.helpers = require('../runtime/helpers.js');
}
56979
public final ProtoParser.header_import_return header_import(Proto proto) throws RecognitionException {
        ProtoParser.header_import_return retval = new ProtoParser.header_import_return();
        retval.start = input.LT(1);

        Object root_0 = null;

        Token IMPORT40=null;
        Token STRING_LITERAL41=null;
        Token SEMICOLON42=null;

        Object IMPORT40_tree=null;
        Object STRING_LITERAL41_tree=null;
        Object SEMICOLON42_tree=null;

        try {
            // com/dyuproject/protostuff/parser/ProtoParser.g:144:5: ( IMPORT STRING_LITERAL SEMICOLON )
            // com/dyuproject/protostuff/parser/ProtoParser.g:144:9: IMPORT STRING_LITERAL SEMICOLON
            {
            root_0 = (Object)adaptor.nil();

            IMPORT40=(Token)match(input,IMPORT,FOLLOW_IMPORT_in_header_import931); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            IMPORT40_tree = (Object)adaptor.create(IMPORT40);
            adaptor.addChild(root_0, IMPORT40_tree);
            }
            STRING_LITERAL41=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_header_import933); if (state.failed) return retval;
            if ( state.backtracking==0 ) {
            STRING_LITERAL41_tree = (Object)adaptor.create(STRING_LITERAL41);
            adaptor.addChild(root_0, STRING_LITERAL41_tree);
            }
            SEMICOLON42=(Token)match(input,SEMICOLON,FOLLOW_SEMICOLON_in_header_import935); if (state.failed) return retval;
            if ( state.backtracking==0 ) {

                          proto.importProto(getStringFromStringLiteral((STRING_LITERAL41!=null?STRING_LITERAL41.getText():null)));
                          
                          if(!proto.annotations.isEmpty())
                              throw new IllegalStateException("Misplaced annotations: " + proto.annotations);
                      
            }

            }

            retval.stop = input.LT(-1);

            if ( state.backtracking==0 ) {

            retval.tree = (Object)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
32891
private static List<ProtoFile> findRelateProtoFiles(File file, Set<String> dependencyNames) throws IOException {
        LinkedList<ProtoFile> protoFiles = new LinkedList<ProtoFile>();
        ProtoFile protoFile = ProtoSchemaParser.parse(file);
        protoFiles.addFirst(protoFile);

        String parent = file.getParent();
        // parse dependency, to find all PROTO file if using import command
        List<String> dependencies = protoFile.getDependencies();
        if (dependencies != null && !dependencies.isEmpty()) {
            for (String fn : dependencies) {
                if (dependencyNames.contains(fn)) {
                    continue;
                }
                File dependencyFile = new File(parent, fn);
                protoFiles.addAll(findRelateProtoFiles(dependencyFile, dependencyNames));
            }
        }
        
        List<String> publicDependencies = protoFile.getPublicDependencies();
        if (publicDependencies != null && !publicDependencies.isEmpty()) {
            for (String fn : publicDependencies) {
                if (dependencyNames.contains(fn)) {
                    continue;
                }
                File dependencyFile = new File(parent, fn);
                protoFiles.addAll(findRelateProtoFiles(dependencyFile, dependencyNames));
            }
        }
        return protoFiles;
    }