Obtain the List of secondary structure information (SecStrucInfo) of a
Structure.

@param s
Structure with SS assignments
@return List of SecStrucInfo objects
433829
public static List<SecStrucInfo> getSecStrucInfo(Structure s) {

		List<SecStrucInfo> listSSI = new ArrayList<SecStrucInfo>();
		GroupIterator iter = new GroupIterator(s);

		while (iter.hasNext()) {
			Group g = iter.next();
			if (g.hasAminoAtoms()) {
				Object p = g.getProperty(Group.SEC_STRUC);
				if (!(p == null)) {
					SecStrucInfo ss = (SecStrucInfo) p;
					listSSI.add(ss);
				}
			}
		}

		return listSSI;
	}
727292
public static String getLogInfo(String s, Object[] params) {
        return DefaultPlaceholderConnector.getInstance().connect(s, params);
    }
72757
public static Scsd cs_scc(Scs A) {
        int n, i, k, b, nb = 0, top, xi[], pstack[], p[], r[], Ap[], ATp[], rcopy[], Blk[];
        Scs AT;
        Scsd S;
        if (!Scs_util.CS_CSC(A))
            return (null); /* check inputs */
        n = A.n;
        Ap = A.p;
        S = Scs_util.cs_dalloc(n, 0); /* allocate result */
        AT = Scs_transpose.cs_transpose(A, false); /* AT = A' */
        xi = new int[2 * n + 1]; /* get workspace */
        if (S == null || AT == null)
            return (null);
        Blk = xi;
        rcopy = xi;
        int rcopy_offset = n;
        pstack = xi;
        int pstack_offset = n;
        p = S.p;
        r = S.r;
        ATp = AT.p;
        top = n;
        for (i = 0; i < n; i++) /* first dfs(A) to find finish times (xi) */
        {
            if (!Scs_util.CS_MARKES(Ap, i))
                top = Scs_dfs.cs_dfs(i, A, top, xi, 0, pstack, pstack_offset, null, 0);
        }
        for (i = 0; i < n; i++)
            Scs_util.CS_MARK(Ap, i); /* restore A; unmark all nodes*/
        top = n;
        nb = n;
        for (k = 0; k < n; k++) /* dfs(A') to find strongly connnected comp */
        {
            i = xi[k]; /* get i in reverse order of finish times */
            if (Scs_util.CS_MARKES(ATp, i))
                continue; /* skip node i if already ordered */
            r[nb--] = top; /* node i is the start of a component in p */
            top = Scs_dfs.cs_dfs(i, AT, top, p, 0, pstack, pstack_offset, null, 0);
        }
        r[nb] = 0; /* first block starts at zero; shift r up */
        for (k = nb; k <= n; k++)
            r[k - nb] = r[k];
        S.nb = nb = n - nb; /* nb = # of strongly connected components */
        for (b = 0; b < nb; b++) /* sort each block in natural order */
        {
            for (k = r[b]; k < r[b + 1]; k++)
                Blk[p[k]] = b;
        }
        for (b = 0; b <= nb; b++)
            rcopy[rcopy_offset + b] = r[b];
        for (i = 0; i < n; i++)
            p[rcopy[rcopy_offset + Blk[i]]++] = i;
        return S;
    }
776761
def get_nts_sections(self, sections, sortby=None):
        """"""
        goids = self.get_goids_sections(sections)
        gosubdag = GoSubDag(goids, self.go2obj)
        return [(sec, gosubdag.get_nts(gos, sortby)) for sec, gos in sections]
162160
public static List<AtomSite> convertStructureToAtomSites(Structure s) {
		List<AtomSite> list = new ArrayList<AtomSite>();

		for (int m=0;m<s.nrModels();m++) {
			for (Chain c:s.getChains(m)) {
				list.addAll(convertChainToAtomSites(c, m+1, c.getName(), c.getId()));
			}
		}
		return list;
	}
265833
private final int stateFirstInStruct()
    {
        int new_state;

        if (hasName()) {
            new_state = S_NAME;
        }
        else if (hasMaxId()) {
            new_state = S_MAX_ID;
        }
        else if (hasImports()) {
            new_state = S_IMPORT_LIST;
        }
        else if (hasLocalSymbols()) {
            new_state = S_SYMBOL_LIST;
        }
        else {
            new_state = S_STRUCT_CLOSE;
        }
        return new_state;
    }
407620
public List<NodeInfo> getNodes() {
    final URI uri = uriWithPath("./nodes/");
    return Arrays.asList(this.rt.getForObject(uri, NodeInfo[].class));
  }
1370326
def get_structure_with_nodes(self):
        
        new_s = Structure.from_sites(self.structure)
        for v in self.vnodes:
            new_s.append("X", v.frac_coords)
        return new_s
562872
public static SecStrucType getSecStructTypeFromDsspIndex(int dsspIndex) {
		String dsspType = DsspType.dsspTypeFromInt(dsspIndex).getDsspType();
		for(SecStrucType secStrucType : SecStrucType.values())
		{
			if(dsspType==secStrucType.name)
			{
				return secStrucType;
			}
		}
		// Return a null entry.
		return null;
	}
1012757
protected List<String> getFileLocationsFromSubsystemContent(String subsystemContent) {
        String sc = subsystemContent + ",";
        List<String> files = new ArrayList<String>();
        boolean isFile = false;
        String location = null;
        int strLen = sc.length();
        boolean quoted = false;
        for (int i = 0, pos = 0; i < strLen; i++) {
            char c = sc.charAt(i);
            if (!quoted && (c == ';' || c == ',')) {
                String str = sc.substring(pos, i);
                pos = i + 1;
                if (logger.isLoggable(Level.FINE)) {
                    logger.fine("element : " + str);
                }
                if (str.contains(":=")) {
                    if (getKey(str).equals(HDR_ATTR_LOCATION)) {
                        location = getValue(str);
                    }
                } else if (str.contains("=")) {
                    if (getKey(str).equals(HDR_ATTR_TYPE) && getValue(str).equals(HDR_ATTR_VALUE_FILE)) {
                        isFile = true;
                    }
                }
                if (c == ',') { // the delimiter of each subsystem content.
                    if (isFile && location != null) {
                        if (logger.isLoggable(Level.FINE)) {
                            logger.fine("location : " + location);
                        }
                        files.add(location);
                    }
                    location = null;
                    isFile = false;
                }
            } else if (c == '\"') {
                quoted = !quoted;
            }
        }
        return files;
    }
66205
public List<I> getNewInstanceList(String[] clsssList) {
        List<I> instances = new ArrayList<>();
        for (String className : clsssList) {
            I instance = new ReflectUtil<I>().getNewInstance(className);
            instances.add(instance);
        }
        return instances;
    }
662457
@Nonnull
  public ICommonsList <String> getHeaders (@Nullable final String sName)
  {
    return new CommonsArrayList <> (m_aHeaders.get (_unifyHeaderName (sName)));
  }
88690
public List<IfSystemProperty<Exclude<T>>> getAllIfSystemProperty()
   {
      List<IfSystemProperty<Exclude<T>>> list = new ArrayList<IfSystemProperty<Exclude<T>>>();
      List<Node> nodeList = childNode.get("if-system-property");
      for(Node node: nodeList)
      {
         IfSystemProperty<Exclude<T>>  type = new IfSystemPropertyImpl<Exclude<T>>(this, "if-system-property", childNode, node);
         list.add(type);
      }
      return list;
   }
614119
public List<SecondaryTable<Entity<T>>> getAllSecondaryTable()
   {
      List<SecondaryTable<Entity<T>>> list = new ArrayList<SecondaryTable<Entity<T>>>();
      List<Node> nodeList = childNode.get("secondary-table");
      for(Node node: nodeList)
      {
         SecondaryTable<Entity<T>>  type = new SecondaryTableImpl<Entity<T>>(this, "secondary-table", childNode, node);
         list.add(type);
      }
      return list;
   }
1089311
public List<String> toList() {
        ArrayList<String> list = new ArrayList<String>();
        for (StringGrabber sg : mSgList) {
            list.add(sg.toString());
        }
        return list;

    }
786462
public Set<Constructor<?>> getConstructors(boolean privileged) {
      if (privileged) {
         return Collections.unmodifiableSet(Sets.union(constructors, declaredConstructors));
      } else {
         return Collections.unmodifiableSet(constructors);
      }
   }
823968
public Atom[] getAlignmentAtoms(Structure s) {
		String[] atomNames = params.getUsedAtomNames();
		return StructureTools.getAtomArray(s, atomNames);
	}