It seems like the browser you are using has JavaScript disabled. As a result, the site will not function properly. We really want you to enable it so you may experience our site as we intended it. If you have no idea what we are talking about or if you need help, visit http://www.enable-javascript.com×
This website uses cookies. By continuing to browse this site you are agreeing to our use of cookies. Find out more on our cookie page.×

Oops, it seems like you're using an old browser that we do not fully support. If you're able to, please upgrade your browser here.×
This website uses cookies. By continuing to browse this site you are agreeing to our use of cookies. Find out more on our cookie page.×

The template class describes an object that controls a
varying-length sequence of elements of type
const Key.
The sequence is
ordered by the predicate
Pr.
Each element serves as both a sort key and a value.
The sequence is represented in a way that permits lookup, insertion,
and removal of an arbitrary element with a number of operations
proportional to the logarithm of the number of elements
in the sequence (logarithmic time). Moreover, inserting an element
invalidates no iterators, and removing an element
invalidates only those iterators which point at the removed element.

The object orders the sequence it controls by calling a
stored function object of type Pr. You access
this stored object by calling the member function
key_comp().
Such a function object must impose a
strict weak ordering
on sort keys of type Key.
For any element X that precedes
Y in the sequence,
key_comp()(Y, X) is false. (For the default function object
less<Key>,
sort keys never decrease in value.)
Unlike template class set,
an object of template class multiset does not ensure that
key_comp()(X, Y) is true.
(Keys need not be unique.)

The object allocates and frees storage for the sequence it controls
through a stored allocator object
of class Alloc. Such an allocator object must have
the same external interface as an object of template class
allocator.
Note that the stored allocator object is not copied when the container
object is assigned.

The signed integer type describes an object that can represent the
difference between the addresses of any two elements in the controlled
sequence. It is described here as a
synonym for the implementation-defined type T3.

The first member function removes the element of the controlled
sequence pointed to by where.
The second member function removes the elements
in the range [first, last).
Both return an iterator that designates the first element remaining
beyond any elements removed, or
end() if no such element exists.

The third member removes
the elements with sort keys in the range
[lower_bound(keyval),
upper_bound(keyval)).
It returns the number of elements it removes.

The member functions never throw an exception.

In this
implementation, the first two
member functions return an iterator that designates the first element remaining
beyond any elements removed, or
end() if no such element exists.

The member function returns an iterator that designates
the earliest element in the controlled sequence whose sort key has
equivalent ordering
to keyval. If no such element exists,
the function returns
end().

The first member function inserts the element val
in the controlled sequence, then returns
the iterator that designates the inserted element.
The second member function returns insert(val),
using where as a starting place within the controlled
sequence to search for the insertion point. (Insertion can occur
in amortized constant time, instead of logarithmic time, if the
insertion point immediately precedes or follows where.)
The third member function
inserts the sequence of element values,
for each it in the range [first, last),
by calling insert(*where).

If an exception is thrown during the
insertion of a single element, the container is left unaltered
and the exception is rethrown.
If an exception is thrown during the
insertion of multiple elements, the container is left in a stable
but unspecified state and the exception is rethrown.

All constructors store an
allocator object and
initialize the controlled sequence. The allocator object is the argument
al, if present. For the copy constructor, it is
right.get_allocator().
Otherwise, it is Alloc().

All constructors also store a function object that can later
be returned by calling
key_comp().
The function object is the argument pred, if present.
For the copy constructor, it is
right.key_comp()).
Otherwise, it is Pr().

The first three constructors specify an
empty initial controlled sequence. The fourth constructor specifies
a copy of the sequence controlled by right.
The last three constructors specify the sequence of element values
[first, last).

The member function returns a reverse bidirectional
iterator that points at the
first element of the sequence (or just beyond the end of an empty
sequence). Hence, it designates the end of the reverse sequence.

The member function swaps the controlled sequences between
*this and right. If
get_allocator()
== right.get_allocator(), it does so in constant time,
it throws an exception only as a result of copying the stored
function object of type Pr, and it invalidates no references, pointers,
or iterators that designate elements in the two controlled sequences.
Otherwise, it performs a number of element assignments and constructor calls
proportional to the number of elements in the two controlled sequences.

The template class describes an object that controls a
varying-length sequence of elements of type const Key.
The sequence is
ordered by the predicate
Pr.
Each element serves as both a sort key and a value.
The sequence is represented in a way that permits lookup, insertion,
and removal of an arbitrary element with a number of operations
proportional to the logarithm of the number of elements
in the sequence (logarithmic time). Moreover, inserting an element
invalidates no iterators, and removing an element
invalidates only those iterators which point at the removed element.

The object orders the sequence it controls by calling a
stored function object of type Pr. You access
this stored object by calling the member function
key_comp().
Such a function object must impose a
strict weak ordering
on sort keys of type Key.
For any element X that precedes
Y in the sequence,
key_comp()(Y, X) is false. (For the default function object
less<Key>,
sort keys never decrease in value.)
Unlike template class multiset,
an object of template class set ensures that
key_comp()(X, Y) is true.
(Each key is unique.)

The object allocates and frees storage for the sequence it controls
through a stored allocator object
of class Alloc. Such an allocator object must have
the same external interface as an object of template class
allocator.
Note that the stored allocator object is not copied when the container
object is assigned.

The signed integer type describes an object that can represent the
difference between the addresses of any two elements in the controlled
sequence. It is described here as a
synonym for the implementation-defined type T3.

The first member function removes the element of the controlled
sequence pointed to by where.
The second member function removes the elements
in the range [first, last).
Both return an iterator that designates the first element remaining
beyond any elements removed, or
end() if no such element exists.

The third member removes
the elements with sort keys in the range
[lower_bound(keyval),
upper_bound(keyval)).
It returns the number of elements it removes.

The member functions never throw an exception.

In this
implementation, the first two
member functions return an iterator that designates the first element remaining
beyond any elements removed, or
end() if no such element exists.

The first member function determines whether an element X
exists in the sequence whose key has
equivalent ordering
to that of val. If not, it creates such
an element X and initializes it with val.
The function then determines the iterator where that
designates X. If an insertion occurred, the function
returns pair(where, true).
Otherwise, it returns pair(where, false).

The second member function returns insert(val).first,
using where as a starting place within the controlled
sequence to search for the insertion point. (Insertion can occur
in amortized constant time, instead of logarithmic time, if the
insertion point immediately precedes or follows where.)
The third member function
inserts the sequence of element values,
for each where in the range [first, last),
by calling insert(*where).

If an exception is thrown during the
insertion of a single element, the container is left unaltered
and the exception is rethrown.
If an exception is thrown during the
insertion of multiple elements, the container is left in a stable
but unspecified state and the exception is rethrown.

The member function returns a reverse bidirectional
iterator that points at the
first element of the sequence (or just beyond the end of an empty
sequence). Hence, it designates the end of the reverse sequence.

All constructors store an
allocator object and
initialize the controlled sequence. The allocator object is the argument
al, if present. For the copy constructor, it is
right.get_allocator().
Otherwise, it is Alloc().

All constructors also store a function object that can later
be returned by calling
key_comp().
The function object is the argument pred, if present.
For the copy constructor, it is
right.key_comp()).
Otherwise, it is Pr().

The first three constructors specify an
empty initial controlled sequence. The fourth constructor specifies
a copy of the sequence controlled by right.
The last three constructors specify the sequence of element values
[first, last).

The member function swaps the controlled sequences between
*this and right. If
get_allocator()
== right.get_allocator(), it does so in constant time,
it throws an exception only as a result of copying the stored
function object of type Pr, and it invalidates no references, pointers,
or iterators that designate elements in the two controlled sequences.
Otherwise, it performs a number of element assignments and constructor calls
proportional to the number of elements in the two controlled sequences.

1. Download the tools

Before you start developing, you'll need to visit the Downloads tab. Here you'll find downloads for the BlackBerry 10 Native SDK, BlackBerry 10 Device Simulator, and some other useful tools.

2. Try the sample apps

Now featuring a filter control, the Sample apps tab allows you to search for samples by name or by feature.

Select either the Core or Cascades radio buttons to display the samples relevant to you.

3. Educate yourself

The Documentation tab contains tons of examples, tutorials, and best practices to guide you along the path towards building an awesome app.

You can access all the documentation that you need in the left-hand navigation.

4. Start developing

The Reference tab is where you'll find essential details about how to use our APIs.

You can use the left-hand navigation to choose how you would like to browse the reference: by module, by topic, or alphabetically. If you have an idea of what you are looking for, start typing it in the Filter box.