Remove a CDS or coding sequence from the transcript sequence
@param accession
@return
336078
public CDSSequence removeCDS(String accession) {
		for (CDSSequence cdsSequence : cdsSequenceList) {
			if (cdsSequence.getAccession().getID().equals(accession)) {
				cdsSequenceList.remove(cdsSequence);
				cdsSequenceHashMap.remove(accession);
				return cdsSequence;
			}
		}
		return null;
	}
1310406
private int removeExplicitCodes() {
        int w = 0;
        for (int i = 0; i < textLength; ++i) {
            byte t = initialTypes[i];
            if (!(t == LRE || t == RLE || t == LRO || t == RLO || t == PDF || t == BN)) {
                embeddings[w] = embeddings[i];
                resultTypes[w] = resultTypes[i];
                resultLevels[w] = resultLevels[i];
                w++;
            }
        }
        return w; // new textLength while explicit levels are removed
    }
296132
@Override
	public CPDefinitionOptionRel removeByC_C(long CPDefinitionId,
		long CPOptionId) throws NoSuchCPDefinitionOptionRelException {
		CPDefinitionOptionRel cpDefinitionOptionRel = findByC_C(CPDefinitionId,
				CPOptionId);

		return remove(cpDefinitionOptionRel);
	}
517156
def scene_remove(sequence_number, scene_id):
        """"""
        return MessageWriter().string("scene.rm").uint64(sequence_number).uint32(scene_id).get()
249189
public CDSSequence addCDS(AccessionID accession, int begin, int end, int phase) throws Exception {
		if (cdsSequenceHashMap.containsKey(accession.getID())) {
			throw new Exception("Duplicate accesion id " + accession.getID());
		}
		CDSSequence cdsSequence = new CDSSequence(this, begin, end, phase); //sense should be the same as parent
		cdsSequence.setAccession(accession);
		cdsSequenceList.add(cdsSequence);
		Collections.sort(cdsSequenceList, new CDSComparator());
		cdsSequenceHashMap.put(accession.getID(), cdsSequence);
		return cdsSequence;
	}
1198440
static Xdr removeRecordMarking(byte[] bytes) {
        Xdr toReturn = new Xdr(bytes.length);
        Xdr input = new Xdr(bytes);

        long fragSize;
        boolean lastFragment = false;

        input.setOffset(0);
        int inputOff = input.getOffset();

        while (!lastFragment) {

            fragSize = input.getUnsignedInt();
            lastFragment = isLastFragment(fragSize);
            fragSize = maskFragmentSize(fragSize);

            toReturn.putBytes(input.getBuffer(), input.getOffset(), (int) fragSize);
            inputOff += fragSize;
            input.setOffset(inputOff);
        }

        // get xid
        int off = toReturn.getOffset();
        toReturn.setOffset(0);
        int xid = toReturn.getInt();
        toReturn.setXid(xid);
        toReturn.setOffset(off);

        return toReturn;
    }
648333
private void removeStaleEntries() {
        FileLockReference ref;
        while ((ref = (FileLockReference)queue.poll()) != null) {
            FileKey fk = ref.fileKey();
            List<FileLockReference> list = lockMap.get(fk);
            if (list != null) {
                synchronized (list) {
                    list.remove(ref);
                    removeKeyIfEmpty(fk, list);
                }
            }
        }
    }
588270
protected Entry<K, V> removeEntry(Entry<K, V> pEntry) {
        if (pEntry == null) {
            return null;
        }

        // Find candidate entry for this key
        Entry<K, V> candidate = getEntry(pEntry.getKey());
        if (candidate == pEntry || (candidate != null && candidate.equals(pEntry))) {
            // Remove
            remove(pEntry.getKey());
            return pEntry;
        }
        return null;
    }
296296
def remove_from_parent_sequence_map(assessment_part_admin_session, assessment_part_id):
    """"""
    apls = get_assessment_part_lookup_session(runtime=assessment_part_admin_session._runtime,
                                              proxy=assessment_part_admin_session._proxy)
    apls.use_federated_bank_view()
    apls.use_unsequestered_assessment_part_view()
    child_part = apls.get_assessment_part(assessment_part_id)
    update_parent_sequence_map(child_part, delete=True)
1008337
private static String convertCommaSeparatedListToEditionString(String csList) throws RepositoryException {

        if (csList == null) {
            return null;
        }

        // Split the comma separated list into an array
        csList = csList.trim();
        List<Edition> editions = new ArrayList<Edition>();
        if (csList.length() > 0) {
            String[] sArray = csList.split(",");
            for (String s : sArray) {
                if (s.length() != 0) {
                    try {
                        editions.add(Edition.valueOf(s));
                    } catch (IllegalArgumentException e) {
                        throw new RepositoryException("The list of editions '" + s + "' contained an invalid edition", e);
                    }
                }
            }
        }

        // convert the editions into a string
        String editionString = null;
        for (Edition ed : editions) {
            if (editionString == null) {
                editionString = "; productEdition=\"";
                editionString = editionString + ed.getProductEdition();
            } else {
                editionString = editionString + "," + ed.getProductEdition();
            }
        }
        if (editionString == null) {
            editionString = "";
        } else {
            editionString = editionString + "\"";
        }
        return editionString;
    }
105893
synchronized List<AllocatedSlice> removeAllAllocatedSlices() {

		final List<AllocatedSlice> slices = new ArrayList<AllocatedSlice>(this.allocatedSlices.values());
		final Iterator<AllocatedSlice> it = slices.iterator();
		while (it.hasNext()) {
			removeAllocatedSlice(it.next().getAllocationID());
		}

		return slices;
	}
1276883
public void unlink(Object source, CollectionDescriptor cds, Object referenceToUnlink)
    {
        if(cds.isMtoNRelation())
        {
            m_broker.deleteMtoNImplementor(new MtoNImplementor(cds, source, referenceToUnlink));
        }
        else
        {
            ClassDescriptor cld = m_broker.getClassDescriptor(referenceToUnlink.getClass());
            m_broker.unlinkFK(referenceToUnlink, cld, cds);
        }
    }
594010
public static ChromPos getChromosomePosForCDScoordinate(int cdsNucleotidePosition, GeneChromosomePosition chromPos) {

		logger.debug(" ? Checking chromosome position for CDS position " + cdsNucleotidePosition);

		List<Integer> exonStarts = chromPos.getExonStarts();
		List<Integer> exonEnds = chromPos.getExonEnds();

		logger.debug(" Exons:" + exonStarts.size());

		int cdsStart = chromPos.getCdsStart();
		int cdsEnd = chromPos.getCdsEnd();


		ChromPos chromosomePos = null;

		if (chromPos.getOrientation().equals('+'))

			chromosomePos = ChromosomeMappingTools.getChromPosForward(cdsNucleotidePosition, exonStarts, exonEnds, cdsStart, cdsEnd);
		else
			chromosomePos = ChromosomeMappingTools.getChromPosReverse(cdsNucleotidePosition, exonStarts, exonEnds, cdsStart, cdsEnd);

		logger.debug("=> CDS pos " + cdsNucleotidePosition + " for " + chromPos.getGeneName() + " is on chromosome at  " + chromosomePos);
		return chromosomePos;

	}
1208332
def _setup_incorporate(self):
        
        seq = list(self._transcript_data.transcript_sequence)

        # get initial start/end points; will modify these based on the variant length
        cds_start = self._transcript_data.cds_start
        cds_stop = self._transcript_data.cds_stop

        start_end = []
        for pos in (self._var_c.posedit.pos.start, self._var_c.posedit.pos.end):
            # list is zero-based; seq pos is 1-based
            if pos.datum == Datum.CDS_START:
                if pos.base < 0:    # 5' UTR
                    result = cds_start - 1
                else:    # cds/intron
                    if pos.offset <= 0:
                        result = (cds_start - 1) + pos.base - 1
                    else:
                        result = (cds_start - 1) + pos.base
            elif pos.datum == Datum.CDS_END:    # 3' UTR
                result = cds_stop + pos.base - 1
            else:
                raise NotImplementedError("Unsupported/unexpected location")
            start_end.append(result)

        # unpack; increment end by 1 (0-based exclusive)
        (start, end) = start_end
        end += 1

        if DBG:
            print("len seq:{} cds_start:{} cds_stop:{} start:{} end:{}".format(
                len(seq), cds_start, cds_stop, start, end))
        return seq, cds_start, cds_stop, start, end
617725
@Override
	public void removeByC_CSO(long CPDefinitionId, long CPSpecificationOptionId) {
		for (CPDefinitionSpecificationOptionValue cpDefinitionSpecificationOptionValue : findByC_CSO(
				CPDefinitionId, CPSpecificationOptionId, QueryUtil.ALL_POS,
				QueryUtil.ALL_POS, null)) {
			remove(cpDefinitionSpecificationOptionValue);
		}
	}
993592
public static RetentionSet removeStreamCutBefore(RetentionSet set, StreamCutReferenceRecord record) {
        Preconditions.checkNotNull(record);
        // remove all stream cuts with recordingTime before supplied cut
        int beforeIndex = getGreatestLowerBound(set, record.getRecordingTime(), StreamCutReferenceRecord::getRecordingTime);
        if (beforeIndex < 0) {
            return set;            
        }
        
        if (beforeIndex + 1 == set.retentionRecords.size()) {
            return new RetentionSet(ImmutableList.of());
        }
        
        return new RetentionSet(set.retentionRecords.subList(beforeIndex + 1, set.retentionRecords.size()));
    }
413954
@DELETE
   @Path("/{entryPath:.+}")
   public Response removeEntry(@PathParam("entryPath") String entryPath)
   {

      SessionProvider sessionProvider = sessionProviderService.getSessionProvider(null);
      try
      {
         regService.removeEntry(sessionProvider, normalizePath(entryPath));
         return null; // minds status 204 'No content'
      }
      catch (PathNotFoundException e)
      {
         return Response.status(Response.Status.NOT_FOUND).build();
      }
      catch (Exception e)
      {
         LOG.error("Remove registry entry failed", e);
         throw new WebApplicationException(e);
      }
   }