<p>Getter for the field <code>projects</code>.</p>

@return a {@link java.util.LinkedList} object.
186468
public LinkedList<Project> getProjects() {
	    if(projects != null) return projects;
	    try
	    {
	        projects = new LinkedList<Project>(getService().getAllProjects());
	        projectName = projectName == null ?  projects.iterator().next().getName() : projectName;
	        
	        return projects;
	    }
	    catch (GreenPepperServerException e)
	    {
	        addActionError(e.getId());
	    }
	    
	    return projects;
	}
612490
public Map<Integer, String> listProjects() throws MPXJException
   {
      MPD9DatabaseReader reader = new MPD9DatabaseReader();
      return reader.listProjects();
   }
205585
public List<Concept> getPathFromRoot() {
        LinkedList<Concept> path = new LinkedList<>();

        Concept node = this;
        while (node != null) {
            path.addFirst(node);
            node = node.parent;
        }

        return path;
    }
1115456
@SuppressWarnings("unchecked")
    public static Set<Project> toProjectList(Vector<Object> projectsParams)
    {
        Set<Project> projects = new TreeSet<Project>();
        for(Object projectParams : projectsParams)
        {
            projects.add(toProject((Vector<Object>)projectParams));
        }
        
        return projects;
    }
1193168
private List<String> getProjectResources() {

        if (m_projectResources == null) {
            try {
                m_projectResources = getCms().readProjectResources(getReferenceProject());
            } catch (Throwable e) {
                LOG.error(e.getLocalizedMessage(), e);
                // use an empty list (all resources are "outside")
                m_projectResources = new ArrayList<String>();
            }
        }
        return m_projectResources;
    }
653886
public List<JavaResource> getProjectInterfaces(Project project)
   {
      final List<JavaResource> classes = new ArrayList<>();
      if (project != null)
      {
         project.getFacet(JavaSourceFacet.class).visitJavaSources(new JavaInterfaceSourceVisitor(classes));
      }
      return classes;
   }
777800
private List<Field> allFields(final Class<?> c) {
        List<Field> l = this.fieldsCache.get(c);
        if (l == null) {
            l = new LinkedList<Field>();
            final Field[] fields = c.getDeclaredFields();
            addAll(l, fields);
            Class<?> sc = c;
            while (((sc = sc.getSuperclass()) != Object.class) && (sc != null)) {
                addAll(l, sc.getDeclaredFields());
            }
            this.fieldsCache.putIfAbsent(c, l);
        }
        return l;
    }
582328
@Override
    public Set<Scope> getProjects() {

        try {
            String url = featureSettings.getJiraBaseUrl() + (featureSettings.getJiraBaseUrl().endsWith("/") ? "" : "/")
                    + PROJECT_REST_SUFFIX;
            ResponseEntity<String> responseEntity = makeRestCall(url);
            String responseBody = responseEntity.getBody();

            JSONArray projects = (JSONArray) parser.parse(responseBody);

            return parseAsScopes(projects);

        } catch (ParseException pe) {
            LOGGER.error("Parser exception when parsing teams", pe);
        } catch (HygieiaException e) {
            LOGGER.error("Error in calling JIRA API", e);
        }
        return Collections.EMPTY_SET;
    }
825085
@Override
    public List<Project> findProjects() {
        List<Project> projectList;
        try {
            projectList = createProjects(ldapDao.getDirectChildren(DnFactory.projects()));
        } catch (NoSuchNodeException | MissingParentException e) {
            LOGGER.error("LDAP exception", e);
            throw new LdapRuntimeException(e);
        }
        return projectList;
    }
1000425
public static List<Entry> projectStructure(Project project) {
        List<Entry> entryList = new LinkedList<>();
        entryList.add(namedObject(DnFactory.project(project)));
        entryList.addAll(createProjectAttributesEntries(project));
        return entryList;
    }
839917
private LinkedList<Class> getClassesToDelete() {
		LinkedHashSet<Class> classesToDelete = new LinkedHashSet<Class>();

		for (Object object : getObjects()) {
			classesToDelete.add(object.getClass());
		}

		return new LinkedList<Class>(classesToDelete);
	}
723564
public Collection<String> getFieldNames()
    {
        Set<String> fieldNames = new LinkedHashSet<String> ();
        
        fieldNames.addAll( keys );
        
        return fieldNames;
        
    }
821735
public List<Integer> getThisWorkerTasks() {
    List<Integer> retval = new LinkedList<>();
    retval.add(delegate.getThisTaskId());
    return retval;
  }
717101
public Map<Integer, String> listProjects() throws MPXJException
   {
      try
      {
         Map<Integer, String> result = new HashMap<Integer, String>();

         List<ResultSetRow> rows = getRows("SELECT PROJ_ID, PROJ_NAME FROM MSP_PROJECTS");
         for (ResultSetRow row : rows)
         {
            processProjectListItem(result, row);
         }

         return result;
      }

      catch (SQLException ex)
      {
         throw new MPXJException(MPXJException.READ_ERROR, ex);
      }
   }
1006069
public CollectionRequest<Section> findByProject(String project) {
    
        String path = String.format("/projects/%s/sections", project);
        return new CollectionRequest<Section>(this, Section.class, path, "GET");
    }
411706
protected Project initProject() {
        return RemoteProjectManager.getInstance().getProject(host, username,
                        password, getProjectIdentifier(), false);
    }
321734
public Vector<Object> getAllProjects()
    {
        try
        {
            List<Project> projects = service.getAllProjects();

            log.debug( "Retrieved All Projects number: " + projects.size() );
            return XmlRpcDataMarshaller.toXmlRpcProjectsParameters( projects );
        }
        catch (Exception e)
        {
            return errorAsVector( e, RETRIEVE_PROJECTS );
        }
    }