BString objects

The BString class is a general container for storing a big string (a long sequence of characters) and for making its manipulation easy and efficient.

The DNAString, RNAString and AAString classes are similar containers but with the more biology-oriented purpose of storing a DNA sequence (DNAString), an RNA sequence (RNAString), or a sequence of amino acids (AAString).

All those containers derive directly (and with no additional slots) from the XString virtual class.

classes, methods

The 2 main differences between an XString object and a standard character vector are: (1) the data stored in an XString object are not copied on object duplication and (2) an XString object can only store a single string (see the XStringSet container for an efficient way to store a big collection of strings in a single object).

Unlike the DNAString, RNAString and AAString containers that accept only a predefined set of letters (the alphabet), a BString object can be used for storing any single string based on a single-byte character set.

Constructor-like functions and generics

In the code snippet below, x can be a single string (character vector of length 1) or an XString object.

BString(x="", start=1, nchar=NA): Tries to convert x into a BString object by reading nchar letters starting at position start in x.

Accessor methods

In the code snippets below, x is an XString object.

alphabet(x): NULL for a BString object. See the corresponding man pages when x is a DNAString, RNAString or AAString object.
length(x) or nchar(x): Get the length of an XString object, i.e., its number of letters.


In the code snippets below, x is an XString object.

as.character(x): Converts x to a character string.
toString(x): Equivalent to as.character(x).


In the code snippets below, x is an XString object.

x[i]: Return a new XString object made of the selected letters (subscript i must be an NA-free numeric vector specifying the positions of the letters to select). The returned object belongs to the same class as x. Note that, unlike subseq, x[i] does copy the sequence data and therefore will be very inefficient for extracting a big number of letters (e.g. when i contains millions of positions).


In the code snippets below, e1 and e2 are XString objects.

e1 == e2: TRUE if e1 is equal to e2. FALSE otherwise. Comparison between two XString objects of different base types (e.g. a BString object and a DNAString object) is not supported with one exception: a DNAString object and an RNAString object can be compared (see RNAString-class for more details about this). Comparison between a BString object and a character string is also supported (see examples below).
e1 != e2: Equivalent to !(e1 == e2).

See Also

subseq, letter, DNAString-class, RNAString-class, AAString-class, XStringSet-class, XStringViews-class, reverseComplement, compact, XVector-class

  • class:XString
  • XString-class
  • class:BString
  • BString-class
  • XString
  • BString
  • alphabet
  • alphabet,ANY-method
  • nchar,XString-method
  • seqtype,BString-method
  • seqtype,DNAString-method
  • seqtype,RNAString-method
  • seqtype,AAString-method
  • seqtype<-,XString-method
  • coerce,XString,BString-method
  • coerce,XString,DNAString-method
  • coerce,XString,RNAString-method
  • coerce,XString,AAString-method
  • coerce,character,BString-method
  • coerce,character,DNAString-method
  • coerce,character,RNAString-method
  • coerce,character,AAString-method
  • coerce,character,XString-method
  • as.character,XString-method
  • toString,XString-method
  • as.vector,XString-method
  • show,XString-method
  • ==,XString,XString-method
  • ==,BString,character-method
  • ==,character,BString-method
  • !=,XString,XString-method
  • !=,BString,character-method
  • !=,character,BString-method
  • substr,XString-method
  • substring,XString-method
  • updateObject,XString-method
b <- BString("I am a BString object")

## Extracting a linear subsequence:
subseq(b, start=3)
subseq(b, start=-3)
subseq(b, end=-3)
subseq(b, end=-3, width=5)

## Subsetting:
b2 <- b[length(b):1]       # better done with reverse(b)


b2 == b                    # FALSE
b2 == as.character(b2)     # TRUE

## b[1:length(b)] is equal but not identical to b!
b == b[1:length(b)]        # TRUE
identical(b, 1:length(b))  # FALSE
## This is because subsetting an XString object with [ makes a copy
## of part or all its sequence data. Hence, for the resulting object,
## the internal slot containing the memory address of the sequence
## data differs from the original. This is enough for identical() to
## see the 2 objects as different.

## Compacting. As a particular type of XVector objects, XString
## objects can optionally be compacted. Compacting is done typically
## before serialization. See ?compact for more information.
Documentation reproduced from package Biostrings, version 2.34.1, License: Artistic-2.0

Community examples

Looks like there are no examples yet.