bool MediaStream::removeTrack(PassRefPtr<MediaStreamTrack> prpTrack)
{
// This is a common part used by removeTrack called by JavaScript
// and removeRemoteTrack and only removeRemoteTrack must fire removetrack event
RefPtr<MediaStreamTrack> track = prpTrack;
Vector<RefPtr<MediaStreamTrack>>* tracks = trackVectorForType(track->source()->type());
size_t pos = tracks->find(track);
if (pos == notFound)
return false;
tracks->remove(pos);
m_private->removeTrack(&track->privateTrack());
// There can be other tracks using the same source in the same MediaStream,
// like when MediaStreamTrack::clone() is called, for instance.
// Spec says that a source can be shared, so we must assure that there is no
// other track using it.
if (!haveTrackWithSource(track->source()))
m_private->removeSource(track->source());
track->removeObserver(this);
if (!m_audioTracks.size() && !m_videoTracks.size())
setActive(false);
return true;
}
void TextTrackList::invalidateTrackIndexesAfterTrack(TextTrack* track)
{
Vector<RefPtr<TextTrack> >* tracks = 0;
if (track->trackType() == TextTrack::TrackElement) {
tracks = &m_elementTracks;
for (size_t i = 0; i < m_addTrackTracks.size(); ++i)
m_addTrackTracks[i]->invalidateTrackIndex();
for (size_t i = 0; i < m_inbandTracks.size(); ++i)
m_inbandTracks[i]->invalidateTrackIndex();
} else if (track->trackType() == TextTrack::AddTrack) {
tracks = &m_addTrackTracks;
for (size_t i = 0; i < m_inbandTracks.size(); ++i)
m_inbandTracks[i]->invalidateTrackIndex();
} else if (track->trackType() == TextTrack::InBand)
tracks = &m_inbandTracks;
else
ASSERT_NOT_REACHED();
size_t index = tracks->find(track);
if (index == kNotFound)
return;
for (size_t i = index; i < tracks->size(); ++i)
tracks->at(index)->invalidateTrackIndex();
}
void WebCL::cacheSupportedExtensions()
{
if (!m_platforms.size())
return;
Vector<String> supportedExtensions = m_platforms[0]->getSupportedExtensions();
if (m_platforms.size() == 1) {
// If there is only one platform, WebCL extensions is equal to this platform's extension.
return;
}
for (auto platform : m_platforms) {
Vector<String> temporary = platform->getSupportedExtensions();
Vector<String> toBeRemoved;
for (auto supportedExtension : supportedExtensions) {
Vector<String>::iterator iter = temporary.begin();
for (; iter != temporary.end(); ++iter) {
if (supportedExtension == *iter)
break;
}
if (iter == temporary.end())
toBeRemoved.append(supportedExtension);
}
for (auto stringToBeRemoved : toBeRemoved)
supportedExtensions.remove(supportedExtensions.find(stringToBeRemoved));
}
for (auto supportedExtension : supportedExtensions)
m_extension.addSupportedCLExtension(supportedExtension);
}
void TextTrackList::remove(TextTrack* track)
{
Vector<RefPtr<TextTrack> >* tracks = 0;
RefPtr<InbandTextTrack> inbandTrack;
if (track->trackType() == TextTrack::TrackElement) {
tracks = &m_elementTracks;
} else if (track->trackType() == TextTrack::AddTrack) {
tracks = &m_addTrackTracks;
} else if (track->trackType() == TextTrack::InBand) {
tracks = &m_inbandTracks;
inbandTrack = static_cast<InbandTextTrack*>(track);
} else {
ASSERT_NOT_REACHED();
}
size_t index = tracks->find(track);
if (index == kNotFound)
return;
invalidateTrackIndexesAfterTrack(track);
ASSERT(track->mediaElement() == m_owner);
track->setMediaElement(0);
tracks->remove(index);
if (inbandTrack)
inbandTrack->trackRemoved();
}
bool TriggerMng::add(unsigned int event, TriggerObj *obj)
{
bool ret = false;
CCAssert(obj != nullptr, "Argument must be non-nil");
do
{
auto iterator = _eventTriggers.find(event);
if (iterator == _eventTriggers.end())
{
auto array = new cocos2d::Vector<TriggerObj*>();
array->pushBack(obj);
_eventTriggers.insert(std::make_pair(event, array));
}
else
{
Vector<TriggerObj*>* temp = iterator->second;
if(temp->find(obj) == temp->end())
{
temp->pushBack(obj);
}
}
ret = true;
} while(0);
return ret;
}
void TextTrackList::invalidateTrackIndexesAfterTrack(TextTrack& track)
{
Vector<RefPtr<TrackBase>>* tracks = nullptr;
switch (track.trackType()) {
case TextTrack::TrackElement:
tracks = &m_elementTracks;
for (auto& addTrack : m_addTrackTracks)
downcast<TextTrack>(addTrack.get())->invalidateTrackIndex();
for (auto& inbandTrack : m_inbandTracks)
downcast<TextTrack>(inbandTrack.get())->invalidateTrackIndex();
break;
case TextTrack::AddTrack:
tracks = &m_addTrackTracks;
for (auto& inbandTrack : m_inbandTracks)
downcast<TextTrack>(inbandTrack.get())->invalidateTrackIndex();
break;
case TextTrack::InBand:
tracks = &m_inbandTracks;
break;
default:
ASSERT_NOT_REACHED();
}
size_t index = tracks->find(&track);
if (index == notFound)
return;
for (size_t i = index; i < tracks->size(); ++i)
downcast<TextTrack>(*tracks->at(index)).invalidateTrackIndex();
}
void TextTrackList::remove(TrackBase& track, bool scheduleEvent)
{
auto& textTrack = downcast<TextTrack>(track);
Vector<RefPtr<TrackBase>>* tracks = nullptr;
switch (textTrack.trackType()) {
case TextTrack::TrackElement:
tracks = &m_elementTracks;
break;
case TextTrack::AddTrack:
tracks = &m_addTrackTracks;
break;
case TextTrack::InBand:
tracks = &m_inbandTracks;
break;
default:
ASSERT_NOT_REACHED();
}
size_t index = tracks->find(&track);
if (index == notFound)
return;
invalidateTrackIndexesAfterTrack(textTrack);
ASSERT(!track.mediaElement() || !element() || track.mediaElement() == element());
track.setMediaElement(nullptr);
Ref<TrackBase> trackRef = *(*tracks)[index];
tracks->remove(index);
if (scheduleEvent)
scheduleRemoveTrackEvent(WTFMove(trackRef));
}
void EditorBitMaskImportPlugin::reimport_multiple_files(const Vector<String>& p_list) {
if (p_list.size() == 0)
return;
Vector<String> sources;
for (int i = 0; i<p_list.size(); i++) {
int idx;
EditorFileSystemDirectory *efsd = EditorFileSystem::get_singleton()->find_file(p_list[i], &idx);
if (efsd) {
for (int j = 0; j<efsd->get_source_count(idx); j++) {
String file = expand_source_path(efsd->get_source_file(idx, j));
if (sources.find(file) == -1) {
sources.push_back(file);
}
}
}
}
if (sources.size()) {
dialog->popup_import(p_list[0]);
dialog->_choose_files(sources);
dialog->_choose_save_dir(p_list[0].get_base_dir());
}
}
Vector<unsigned> WMLSelectElement::parseIndexValueString(const String& indexValue) const
{
Vector<unsigned> indices;
if (indexValue.isEmpty())
return indices;
Vector<String> indexStrings;
indexValue.split(';', indexStrings);
bool ok = false;
unsigned optionCount = SelectElement::optionCount(m_data, this);
Vector<String>::const_iterator end = indexStrings.end();
for (Vector<String>::const_iterator it = indexStrings.begin(); it != end; ++it) {
unsigned parsedValue = (*it).toUIntStrict(&ok);
// Spec: Remove all non-integer indices from the value. Remove all out-of-range indices
// from the value, where out-of-range is defined as any index with a value greater than
// the number of options in the select or with a value less than one.
if (!ok || parsedValue < 1 || parsedValue > optionCount)
continue;
// Spec: Remove duplicate indices.
if (indices.find(parsedValue) == notFound)
indices.append(parsedValue);
}
return indices;
}
void TestFind ( Vector<T> & V, int n ) {
for ( int i = 0; i < V.size(); i++ ) { //依次查找向量中元素，当然成功
T e = V[i]; print ( e );
Rank r = V.find ( e );
if ( r < 0 ) printf ( " : not found until rank V[%d] <> %d", r, e );
else printf ( " : found at rank V[%d] = %d", r, V[r] );
printf ( "\n" );
}
for ( int i = 0; i <= V.size(); i++ ) { //依次查找每对相邻元素的均值，可能成功
T a = ( 0 < i ) ? V[i-1] : -INT_MAX / 2;
T b = ( i < V.size() ) ? V[i] : INT_MAX / 2;
T e = ( a + b ) / 2; print ( e );
Rank r = V.find ( e );
if ( r < 0 ) printf ( " : not found until rank V[%d] <> %d", r, e );
else printf ( " : found at rank V[%d] = %d", r, V[r] );
printf ( "\n" );
}
}
void LayerWebKitThread::remove(Vector<RefPtr<LayerWebKitThread> >& vector, LayerWebKitThread* sublayer)
{
size_t foundIndex = vector.find(sublayer);
if (foundIndex == notFound)
return;
sublayer->setSuperlayer(0);
vector.remove(foundIndex);
setNeedsCommit();
}
void EditorFileDialog::_favorite_move_down() {
int current = favorites->get_current();
if (current >= 0 && current < favorites->get_item_count() - 1) {
Vector<String> favorited = EditorSettings::get_singleton()->get_favorite_dirs();
int a_idx = favorited.find(String(favorites->get_item_metadata(current + 1)));
int b_idx = favorited.find(String(favorites->get_item_metadata(current)));
if (a_idx == -1 || b_idx == -1)
return;
SWAP(favorited[a_idx], favorited[b_idx]);
EditorSettings::get_singleton()->set_favorite_dirs(favorited);
_update_favorites();
update_file_list();
}
}
void HTMLFormElement::getNamedElements(const AtomicString& name, Vector<RefPtr<Node> >& namedItems)
{
// http://www.whatwg.org/specs/web-apps/current-work/multipage/forms.html#dom-form-nameditem
elements()->namedItems(name, namedItems);
// FIXME: The specification says we should not add the element from the past when names map when namedItems is not empty.
HTMLFormControlElement* elementFromPast = elementFromPastNamesMap(name);
if (namedItems.size() == 1 && namedItems.first() != elementFromPast)
addElementToPastNamesMap(static_cast<HTMLFormControlElement*>(namedItems.first().get()), name);
else if (elementFromPast && namedItems.find(elementFromPast) == notFound)
namedItems.append(elementFromPast);
}
void test_const_iterator()
{
const Vector<int> v({2,3,4,5,6});
int i = 2;
for( VectorIterator<int> it = v.begin(); it != v.end(); ++it )
{
TS_ASSERT_EQUALS( *it, i++ );
}
VectorIterator<int> it2 = v.find(5);
TS_ASSERT_EQUALS( *it2, 5);
it2 = v.find(3);
TS_ASSERT_EQUALS( *it2, 3 );
VectorIterator<int> it3 = v.end();
it3--;
TS_ASSERT_EQUALS( *it3, 6 );
std::iterator<std::random_access_iterator_tag, int>::difference_type diff = it3 - it2;
it2 = it2 + diff;
TS_ASSERT_EQUALS( it2, it3 );
}
void ScenesDock::_fav_down_pressed() {
TreeItem *sel = tree->get_selected();
if (!sel)
return ;
if (!sel->get_next())
return;
String sw = sel->get_next()->get_metadata(0);
String txt = sel->get_metadata(0);
Vector<String> favorited = EditorSettings::get_singleton()->get_favorite_dirs();
int a_idx=favorited.find(sw);
int b_idx=favorited.find(txt);
if (a_idx==-1 || b_idx==-1)
return;
SWAP(favorited[a_idx],favorited[b_idx]);
EditorSettings::get_singleton()->set_favorite_dirs(favorited);
_update_tree();
if (!tree->get_root() || !tree->get_root()->get_children() || !tree->get_root()->get_children()->get_children())
return;
sel = tree->get_root()->get_children()->get_children();
while(sel) {
String t = sel->get_metadata(0);
if (t==txt) {
sel->select(0);
return;
}
sel=sel->get_next();
}
}
// Finds and removes an edge from the list by doing a swap with the
// last element of the list.
void CCLayerSorter::removeEdgeFromList(GraphEdge* edge, Vector<GraphEdge*>& list)
{
size_t edgeIndex = list.find(edge);
ASSERT(edgeIndex != notFound);
if (list.size() == 1) {
ASSERT(!edgeIndex);
list.clear();
return;
}
if (edgeIndex != list.size() - 1)
list[edgeIndex] = list[list.size() - 1];
list.removeLast();
}
void HTMLFormElement::getNamedElements(const AtomicString& name, Vector<RefPtr<Node> >& namedItems)
{
elements()->namedItems(name, namedItems);
HTMLFormControlElement* aliasElement = elementForAlias(name);
if (aliasElement) {
if (namedItems.find(aliasElement) == notFound) {
// We have seen it before but it is gone now. Still, we need to return it.
// FIXME: The above comment is not clear enough; it does not say why we need to do this.
namedItems.append(aliasElement);
}
}
if (namedItems.size() && namedItems.first() != aliasElement)
addElementAlias(static_cast<HTMLFormControlElement*>(namedItems.first().get()), name);
}
static unsigned logicalOffsetInTextNode(const LayoutSVGInlineText& textLayoutObject, const SVGInlineTextBox* startTextBox, unsigned fragmentOffset)
{
Vector<SVGInlineTextBox*> textBoxes;
collectTextBoxesInLogicalOrder(textLayoutObject, textBoxes);
ASSERT(startTextBox);
size_t index = textBoxes.find(startTextBox);
ASSERT(index != kNotFound);
unsigned offset = fragmentOffset;
while (index) {
--index;
offset += textBoxes[index]->len();
}
return offset;
}
PassRefPtr<Widget> FrameLoaderClientWx::createPlugin(const IntSize& size, HTMLPlugInElement* element, const KURL& url, const Vector<String>& paramNames, const Vector<String>& paramValues, const String& mimeType, bool loadManually)
{
#if __WXMSW__ || __WXMAC__
Vector<String> params = paramNames;
Vector<String> values = paramValues;
// until wmode=transparent renders correctly, force Flash movies to be opaque
size_t wmodeIndex = params.find("wmode");
if (wmodeIndex != -1)
values[wmodeIndex] = "window";
RefPtr<PluginView> pv = PluginView::create(m_frame, size, element, url, params, values, mimeType, loadManually);
if (pv->status() == PluginStatusLoadedSuccessfully)
return pv;
#endif
return 0;
}
static CString buildAcceptLanguages(const Vector<String>& languages)
{
size_t languagesCount = languages.size();
// Ignore "C" locale.
size_t cLocalePosition = languages.find("c");
if (cLocalePosition != notFound)
languagesCount--;
// Fallback to "en" if the list is empty.
if (!languagesCount)
return "en";
// Calculate deltas for the quality values.
int delta;
if (languagesCount < 10)
delta = 10;
else if (languagesCount < 20)
delta = 5;
else
delta = 1;
// Set quality values for each language.
StringBuilder builder;
for (size_t i = 0; i < languages.size(); ++i) {
if (i == cLocalePosition)
continue;
if (i)
builder.appendLiteral(", ");
builder.append(languages[i]);
int quality = 100 - i * delta;
if (quality > 0 && quality < 100) {
char buffer[8];
g_ascii_formatd(buffer, 8, "%.2f", quality / 100.0);
builder.append(String::format(";q=%s", buffer));
}
}
return builder.toString().utf8();
}
bool WebPageSerializer::retrieveAllResources(WebView* view,
const WebVector<WebCString>& supportedSchemes,
WebVector<WebURL>* resourceURLs,
WebVector<WebURL>* frameURLs) {
WebLocalFrameImpl* mainFrame = toWebLocalFrameImpl(view->mainFrame());
if (!mainFrame)
return false;
Vector<LocalFrame*> framesToVisit;
Vector<LocalFrame*> visitedFrames;
Vector<KURL> frameKURLs;
Vector<KURL> resourceKURLs;
// Let's retrieve the resources from every frame in this page.
framesToVisit.append(mainFrame->frame());
while (!framesToVisit.isEmpty()) {
LocalFrame* frame = framesToVisit[0];
framesToVisit.remove(0);
retrieveResourcesForFrame(frame, supportedSchemes,
&visitedFrames, &framesToVisit,
&frameKURLs, &resourceKURLs);
}
// Converts the results to WebURLs.
WebVector<WebURL> resultResourceURLs(resourceKURLs.size());
for (size_t i = 0; i < resourceKURLs.size(); ++i) {
resultResourceURLs[i] = resourceKURLs[i];
// A frame's src can point to the same URL as another resource, keep the
// resource URL only in such cases.
size_t index = frameKURLs.find(resourceKURLs[i]);
if (index != kNotFound)
frameKURLs.remove(index);
}
*resourceURLs = resultResourceURLs;
WebVector<WebURL> resultFrameURLs(frameKURLs.size());
for (size_t i = 0; i < frameKURLs.size(); ++i)
resultFrameURLs[i] = frameKURLs[i];
*frameURLs = resultFrameURLs;
return true;
}
void TextureMapperCache::mark(BitmapTexture* texture)
{
if (!texture || !texture->isValid())
return;
Entry entry(texture);
size_t index = m_data.find(entry);
if (!index)
return;
int previousCost = 0;
if (index < m_data.size()) {
previousCost = m_data[index].previousCost;
m_data.remove(index);
}
const int cost = entry.computeCost();
m_totalCost -= previousCost;
m_totalCost += (entry.previousCost = cost);
m_data.prepend(entry);
}
void TextTrackList::remove(TextTrack* track)
{
Vector<RefPtr<TextTrack> >* tracks = 0;
if (track->trackType() == TextTrack::TrackElement)
tracks = &m_elementTracks;
else if (track->trackType() == TextTrack::AddTrack)
tracks = &m_addTrackTracks;
else if (track->trackType() == TextTrack::InBand)
tracks = &m_inbandTracks;
else
ASSERT_NOT_REACHED();
size_t index = tracks->find(track);
if (index == notFound)
return;
invalidateTrackIndexesAfterTrack(track);
ASSERT(track->mediaElement() == m_owner);
track->setMediaElement(0);
tracks->remove(index);
}
void _choose_file(const String& p_path) {
import_path->set_text(p_path);
FileAccess *f = FileAccess::open(p_path,FileAccess::READ);
if (!f) {
error_dialog->set_text(TTR("Invalid source!"));
error_dialog->popup_centered(Size2(200,100));
return;
}
Vector<String> csvh = f->get_csv_line();
memdelete(f);
if (csvh.size()<2) {
error_dialog->set_text(TTR("Invalid translation source!"));
error_dialog->popup_centered(Size2(200,100));
return;
}
columns->clear();
columns->set_columns(2);
TreeItem *root = columns->create_item();
columns->set_hide_root(true);
columns->set_column_titles_visible(true);
columns->set_column_title(0,TTR("Column"));
columns->set_column_title(1,TTR("Language"));
Vector<String> langs = TranslationServer::get_all_locales();
Vector<String> names = TranslationServer::get_all_locale_names();
if (csvh[0]=="")
ignore_first->set_pressed(true);
items.clear();
for(int i=1;i<csvh.size();i++) {
TreeItem *ti = columns->create_item(root);
ti->set_editable(0,true);
ti->set_selectable(0,false);
ti->set_cell_mode(0,TreeItem::CELL_MODE_CHECK);
ti->set_checked(0,true);
ti->set_text(0,itos(i));
items.push_back(ti);
String lname = csvh[i].to_lower().strip_edges();
int idx=-1;
String hint;
for(int j=0;j<langs.size();j++) {
if (langs[j]==lname.substr(0,langs[j].length()).to_lower()) {
idx=j;
}
if (j>0) {
hint+=",";
}
hint+=names[j].replace(","," ");
}
ti->set_cell_mode(1,TreeItem::CELL_MODE_RANGE);
ti->set_text(1,hint);
ti->set_editable(1,true);
if (idx!=-1) {
ignore_first->set_pressed(true);
ti->set_range(1,idx);
} else {
//not found, maybe used stupid name
if (lname.begins_with("br")) //brazilian
ti->set_range(1,langs.find("pt"));
else if (lname.begins_with("ch")) //chinese
ti->set_range(1,langs.find("zh"));
else if (lname.begins_with("sp")) //spanish
ti->set_range(1,langs.find("es"));
else if (lname.begins_with("kr"))// kprean
ti->set_range(1,langs.find("ko"));
else if (i==0)
ti->set_range(1,langs.find("en"));
else
ti->set_range(1,langs.find("es"));
}
ti->set_metadata(1,names[ti->get_range(1)]);
}
}
int main()
{
Vector<double> a (50 ,1024); // ok: defaultkonstruktor ger vektor med flyttal
a.push_back(2048);
assert(a.capacity() >= 51);
a.insert(0, 123);
a.insert(2, 1337);
a.insert(5, 123);
cout << *a.end() << endl;
a.print();
assert(*(a.end()-1) == 2048);
assert(*a.begin() == 123);
a.clear();
assert(a.begin() == a.end());
assert(*a.find(1337) != 1337);
a.print();
try {
a.erase(99999);
} catch (std::out_of_range e) {
std::cout << e.what() << std::endl;
}
a.push_back(55);
a.push_back(56);
a.insert(1,321);
a.insert(1,321);
a.insert(1,321);
a.insert(1,321);
a.insert(1,321);
a.insert(1,321);
a.insert(1,321);
a.insert(0, 55);
assert(a.size() == 10);
a.print();
a[0] = 1;
a[3] = 4;
try {
a[10] = 1;
} catch (std::out_of_range e) {
std::cout << e.what() << std::endl;
}
try {
a[99999] = 5;
} catch (std::out_of_range e) {
std::cout << e.what() << std::endl;
}
a.print();
assert(a.size() == 10);
assert(a[0] == 1);
assert(a[3] == 4);
try {
assert(a[10] == 1);
} catch (std::out_of_range e) {
std::cout << e.what() << std::endl;
}
try {
assert(a[99999] == 5);
} catch (std::out_of_range e) {
std::cout << e.what() << std::endl;
}
a.print();
assert(a.size() == 10);
a.reset();
Vector<int> b;
b.push_back(1);
b.push_back(2);
b.insert(0, 3);
assert(b.capacity() > 3);
b.clear();
assert(b.capacity() > 3);
assert(b.size() == 0);
a.print();
Vector<int> v (2, 5);
cout << v.capacity() << endl;
v.push_back(5);
v.push_back(5);
v.push_back(5);
cout << v.capacity() << endl;
v.print();
a.print();
const Vector<int> v2 {1,2,3};
auto beg = v2.begin();
assert(beg == (v2.end() - v2.size()));
cout << beg << endl;
//*beg = 5;
Vector<int> v3 {1,2,3};
*v3.begin() = 3;
a.print();
std::cout << "int: " << std::is_move_assignable<int>::value << std::endl;
return 0;
}
void TextureProgress::_notification(int p_what) {
const float corners[12] = { -0.125, -0.375, -0.625, -0.875, 0.125, 0.375, 0.625, 0.875, 1.125, 1.375, 1.625, 1.875 };
switch (p_what) {
case NOTIFICATION_DRAW: {
if (nine_patch_stretch && (mode == FILL_LEFT_TO_RIGHT || mode == FILL_RIGHT_TO_LEFT || mode == FILL_TOP_TO_BOTTOM || mode == FILL_BOTTOM_TO_TOP)) {
if (under.is_valid()) {
draw_nine_patch_stretched(under, FILL_LEFT_TO_RIGHT, 1.0, tint_under);
}
if (progress.is_valid()) {
draw_nine_patch_stretched(progress, mode, get_as_ratio(), tint_progress);
}
if (over.is_valid()) {
draw_nine_patch_stretched(over, FILL_LEFT_TO_RIGHT, 1.0, tint_over);
}
} else {
if (under.is_valid())
draw_texture(under, Point2(), tint_under);
if (progress.is_valid()) {
Size2 s = progress->get_size();
switch (mode) {
case FILL_LEFT_TO_RIGHT: {
Rect2 region = Rect2(Point2(), Size2(s.x * get_as_ratio(), s.y));
draw_texture_rect_region(progress, region, region, tint_progress);
} break;
case FILL_RIGHT_TO_LEFT: {
Rect2 region = Rect2(Point2(s.x - s.x * get_as_ratio(), 0), Size2(s.x * get_as_ratio(), s.y));
draw_texture_rect_region(progress, region, region, tint_progress);
} break;
case FILL_TOP_TO_BOTTOM: {
Rect2 region = Rect2(Point2(), Size2(s.x, s.y * get_as_ratio()));
draw_texture_rect_region(progress, region, region, tint_progress);
} break;
case FILL_BOTTOM_TO_TOP: {
Rect2 region = Rect2(Point2(0, s.y - s.y * get_as_ratio()), Size2(s.x, s.y * get_as_ratio()));
draw_texture_rect_region(progress, region, region, tint_progress);
} break;
case FILL_CLOCKWISE:
case FILL_COUNTER_CLOCKWISE:
case FILL_CLOCKWISE_AND_COUNTER_CLOCKWISE: {
float val = get_as_ratio() * rad_max_degrees / 360;
if (val == 1) {
Rect2 region = Rect2(Point2(), s);
draw_texture_rect_region(progress, region, region, tint_progress);
} else if (val != 0) {
Array pts;
float direction = mode == FILL_COUNTER_CLOCKWISE ? -1 : 1;
float start;
if (mode == FILL_CLOCKWISE_AND_COUNTER_CLOCKWISE) {
start = rad_init_angle / 360 - val / 2;
} else {
start = rad_init_angle / 360;
}
float end = start + direction * val;
pts.append(start);
pts.append(end);
float from = MIN(start, end);
float to = MAX(start, end);
for (int i = 0; i < 12; i++)
if (corners[i] > from && corners[i] < to)
pts.append(corners[i]);
pts.sort();
Vector<Point2> uvs;
Vector<Point2> points;
uvs.push_back(get_relative_center());
points.push_back(Point2(s.x * get_relative_center().x, s.y * get_relative_center().y));
for (int i = 0; i < pts.size(); i++) {
Point2 uv = unit_val_to_uv(pts[i]);
if (uvs.find(uv) >= 0)
continue;
uvs.push_back(uv);
points.push_back(Point2(uv.x * s.x, uv.y * s.y));
}
Vector<Color> colors;
colors.push_back(tint_progress);
draw_polygon(points, colors, uvs, progress);
}
if (Engine::get_singleton()->is_editor_hint()) {
Point2 p = progress->get_size();
p.x *= get_relative_center().x;
p.y *= get_relative_center().y;
p = p.floor();
draw_line(p - Point2(8, 0), p + Point2(8, 0), Color(0.9, 0.5, 0.5), 2);
draw_line(p - Point2(0, 8), p + Point2(0, 8), Color(0.9, 0.5, 0.5), 2);
}
} break;
case FILL_BILINEAR_LEFT_AND_RIGHT: {
Rect2 region = Rect2(Point2(s.x / 2 - s.x * get_as_ratio() / 2, 0), Size2(s.x * get_as_ratio(), s.y));
draw_texture_rect_region(progress, region, region, tint_progress);
} break;
case FILL_BILINEAR_TOP_AND_BOTTOM: {
Rect2 region = Rect2(Point2(0, s.y / 2 - s.y * get_as_ratio() / 2), Size2(s.x, s.y * get_as_ratio()));
draw_texture_rect_region(progress, region, region, tint_progress);
} break;
default:
draw_texture_rect_region(progress, Rect2(Point2(), Size2(s.x * get_as_ratio(), s.y)), Rect2(Point2(), Size2(s.x * get_as_ratio(), s.y)), tint_progress);
}
}
if (over.is_valid())
draw_texture(over, Point2(), tint_over);
}
} break;
}
}
void TemplateVectorTest::onEnter()
{
UnitTestDemo::onEnter();
Vector<Node*> vec;
CCASSERT(vec.empty(), "");
CCASSERT(vec.capacity() == 0, "");
CCASSERT(vec.size() == 0, "");
CCASSERT(vec.max_size() > 0, "");
auto node1 = Node::create();
node1->setTag(1);
vec.pushBack(node1);
CCASSERT(node1->getReferenceCount() == 2, "");
auto node2 = Node::create();
node2->setTag(2);
vec.pushBack(node2);
CCASSERT(vec.getIndex(node1) == 0, "");
CCASSERT(vec.getIndex(node2) == 1, "");
auto node3 = Node::create();
node3->setTag(3);
vec.insert(1, node3);
CCASSERT(vec.at(0)->getTag() == 1, "");
CCASSERT(vec.at(1)->getTag() == 3, "");
CCASSERT(vec.at(2)->getTag() == 2, "");
// Test copy constructor
Vector<Node*> vec2(vec);
CCASSERT(vec2.size() == vec.size(), "");
ssize_t size = vec.size();
for (ssize_t i = 0; i < size; ++i)
{
CCASSERT(vec2.at(i) == vec.at(i), "");
CCASSERT(vec.at(i)->getReferenceCount() == 3, "");
CCASSERT(vec2.at(i)->getReferenceCount() == 3, "");
}
// Test copy assignment operator
Vector<Node*> vec3;
vec3 = vec2;
CCASSERT(vec3.size() == vec2.size(), "");
size = vec3.size();
for (ssize_t i = 0; i < size; ++i)
{
CCASSERT(vec3.at(i) == vec2.at(i), "");
CCASSERT(vec3.at(i)->getReferenceCount() == 4, "");
CCASSERT(vec2.at(i)->getReferenceCount() == 4, "");
CCASSERT(vec.at(i)->getReferenceCount() == 4, "");
}
// Test move constructor
auto createVector = [this]() {
Vector<Node*> ret;
for (int i = 0; i < 20; i++)
{
ret.pushBack(Node::create());
}
int j = 1000;
for (auto& child : ret)
{
child->setTag(j++);
}
return ret;
};
Vector<Node*> vec4(createVector());
for (const auto& child : vec4)
{
CC_UNUSED_PARAM(child);
CCASSERT(child->getReferenceCount() == 2, "");
}
// Test init Vector<T> with capacity
Vector<Node*> vec5(10);
CCASSERT(vec5.capacity() == 10, "");
vec5.reserve(20);
CCASSERT(vec5.capacity() == 20, "");
CCASSERT(vec5.size() == 0, "");
CCASSERT(vec5.empty(), "");
auto toRemovedNode = Node::create();
vec5.pushBack(toRemovedNode);
CCASSERT(toRemovedNode->getReferenceCount() == 2, "");
// Test move assignment operator
vec5 = createVector();
CCASSERT(toRemovedNode->getReferenceCount() == 1, "");
CCASSERT(vec5.size() == 20, "size should be 20");
for (const auto& child : vec5)
{
CC_UNUSED_PARAM(child);
CCASSERT(child->getReferenceCount() == 2, "");
}
// Test Vector<T>::find
CCASSERT(vec.find(node3) == (vec.begin() + 1), "");
CCASSERT(std::find(std::begin(vec), std::end(vec), node2) == (vec.begin() + 2), "");
CCASSERT(vec.front()->getTag() == 1, "");
CCASSERT(vec.back()->getTag() == 2, "");
CCASSERT(vec.getRandomObject(), "");
CCASSERT(!vec.contains(Node::create()), "");
CCASSERT(vec.contains(node1), "");
CCASSERT(vec.contains(node2), "");
CCASSERT(vec.contains(node3), "");
CCASSERT(vec.equals(vec2), "");
CCASSERT(vec.equals(vec3), "");
// Insert
vec5.insert(2, node1);
CCASSERT(vec5.at(2)->getTag() == 1, "");
CCASSERT(vec5.size() == 21, "");
vec5.back()->setTag(100);
vec5.popBack();
CCASSERT(vec5.size() == 20, "");
CCASSERT(vec5.back()->getTag() != 100, "");
// Erase and clear
Vector<Node*> vec6 = createVector();
Vector<Node*> vec7 = vec6; // Copy for check
CCASSERT(vec6.size() == 20, "");
vec6.erase(vec6.begin() + 1); //
CCASSERT(vec6.size() == 19, "");
CCASSERT((*(vec6.begin() + 1))->getTag() == 1002, "");
vec6.erase(vec6.begin() + 2, vec6.begin() + 10);
CCASSERT(vec6.size() == 11, "");
CCASSERT(vec6.at(0)->getTag() == 1000, "");
CCASSERT(vec6.at(1)->getTag() == 1002, "");
CCASSERT(vec6.at(2)->getTag() == 1011, "");
CCASSERT(vec6.at(3)->getTag() == 1012, "");
vec6.erase(3);
CCASSERT(vec6.at(3)->getTag() == 1013, "");
vec6.eraseObject(vec6.at(2));
CCASSERT(vec6.at(2)->getTag() == 1013, "");
vec6.clear();
auto objA = Node::create(); // retain count is 1
auto objB = Node::create();
auto objC = Node::create();
{
Vector<Node*> array1;
Vector<Node*> array2;
// push back objA 3 times
array1.pushBack(objA); // retain count is 2
array1.pushBack(objA); // retain count is 3
array1.pushBack(objA); // retain count is 4
array2.pushBack(objA); // retain count is 5
array2.pushBack(objB);
array2.pushBack(objC);
for (auto obj : array1) {
array2.eraseObject(obj);
}
CCASSERT(objA->getReferenceCount() == 4, "");
}
CCASSERT(objA->getReferenceCount() == 1, "");
{
Vector<Node*> array1;
// push back objA 3 times
array1.pushBack(objA); // retain count is 2
array1.pushBack(objA); // retain count is 3
array1.pushBack(objA); // retain count is 4
CCASSERT(objA->getReferenceCount() == 4, "");
array1.eraseObject(objA, true); // Remove all occurrences in the Vector.
CCASSERT(objA->getReferenceCount() == 1, "");
array1.pushBack(objA); // retain count is 2
array1.pushBack(objA); // retain count is 3
array1.pushBack(objA); // retain count is 4
array1.eraseObject(objA, false);
CCASSERT(objA->getReferenceCount() == 3, ""); // Only remove the first occurrence in the Vector.
}
// Check the retain count in vec7
CCASSERT(vec7.size() == 20, "");
for (const auto& child : vec7)
{
CC_UNUSED_PARAM(child);
CCASSERT(child->getReferenceCount() == 2, "");
}
// Sort
Vector<Node*> vecForSort = createVector();
std::sort(vecForSort.begin(), vecForSort.end(), [](Node* a, Node* b) {
return a->getTag() >= b->getTag();
});
for (int i = 0; i < 20; ++i)
{
CCASSERT(vecForSort.at(i)->getTag() - 1000 == (19 - i), "");
}
// Reverse
vecForSort.reverse();
for (int i = 0; i < 20; ++i)
{
CCASSERT(vecForSort.at(i)->getTag() - 1000 == i, "");
}
// Swap
Vector<Node*> vecForSwap = createVector();
vecForSwap.swap(2, 4);
CCASSERT(vecForSwap.at(2)->getTag() == 1004, "");
CCASSERT(vecForSwap.at(4)->getTag() == 1002, "");
vecForSwap.swap(vecForSwap.at(2), vecForSwap.at(4));
CCASSERT(vecForSwap.at(2)->getTag() == 1002, "");
CCASSERT(vecForSwap.at(4)->getTag() == 1004, "");
// shrinkToFit
Vector<Node*> vecForShrink = createVector();
vecForShrink.reserve(100);
CCASSERT(vecForShrink.capacity() == 100, "");
vecForShrink.pushBack(Node::create());
vecForShrink.shrinkToFit();
CCASSERT(vecForShrink.capacity() == 21, "");
// get random object
// Set the seed by time
srand((unsigned)time(nullptr));
Vector<Node*> vecForRandom = createVector();
log("<--- begin ---->");
for (int i = 0; i < vecForRandom.size(); ++i)
{
log("Vector: random object tag = %d", vecForRandom.getRandomObject()->getTag());
}
log("<---- end ---->");
// Self assignment
Vector<Node*> vecSelfAssign = createVector();
vecSelfAssign = vecSelfAssign;
CCASSERT(vecSelfAssign.size() == 20, "");
for (const auto& child : vecSelfAssign)
{
CC_UNUSED_PARAM(child);
CCASSERT(child->getReferenceCount() == 2, "");
}
vecSelfAssign = std::move(vecSelfAssign);
CCASSERT(vecSelfAssign.size() == 20, "");
for (const auto& child : vecSelfAssign)
{
CC_UNUSED_PARAM(child);
CCASSERT(child->getReferenceCount() == 2, "");
}
// const at
Vector<Node*> vecConstAt = createVector();
constFunc(vecConstAt);
}
PassRefPtr<Widget> FrameLoaderClientQt::createPlugin(const IntSize& pluginSize, HTMLPlugInElement* element, const KURL& url, const Vector<String>& paramNames,
const Vector<String>& paramValues, const String& mimeType, bool loadManually)
{
// qDebug()<<"------ Creating plugin in FrameLoaderClientQt::createPlugin for "<<url.prettyURL() << mimeType;
// qDebug()<<"------\t url = "<<url.prettyURL();
if (!m_webFrame)
return 0;
QStringList params;
QStringList values;
QString classid(element->getAttribute("classid"));
for (unsigned i = 0; i < paramNames.size(); ++i) {
params.append(paramNames[i]);
if (paramNames[i] == "classid")
classid = paramValues[i];
}
for (unsigned i = 0; i < paramValues.size(); ++i)
values.append(paramValues[i]);
QString urlStr(url.string());
QUrl qurl = urlStr;
QObject* object = 0;
if (mimeType == "application/x-qt-plugin" || mimeType == "application/x-qt-styled-widget") {
object = m_webFrame->page()->createPlugin(classid, qurl, params, values);
#ifndef QT_NO_STYLE_STYLESHEET
QWidget* widget = qobject_cast<QWidget*>(object);
if (widget && mimeType == "application/x-qt-styled-widget") {
QString styleSheet = element->getAttribute("style");
if (!styleSheet.isEmpty())
styleSheet += QLatin1Char(';');
for (unsigned i = 0; i < numqStyleSheetProperties; ++i) {
CSSPropertyID property = qstyleSheetProperties[i];
styleSheet += QString::fromLatin1(::getPropertyName(property));
styleSheet += QLatin1Char(':');
styleSheet += computedStyle(element)->getPropertyValue(property);
styleSheet += QLatin1Char(';');
}
widget->setStyleSheet(styleSheet);
}
#endif // QT_NO_STYLE_STYLESHEET
}
if (!object) {
QWebPluginFactory* factory = m_webFrame->page()->pluginFactory();
if (factory)
object = factory->create(mimeType, qurl, params, values);
}
if (object) {
QWidget* widget = qobject_cast<QWidget*>(object);
if (widget) {
QWidget* parentWidget = 0;
if (m_webFrame->page()->d->client)
parentWidget = qobject_cast<QWidget*>(m_webFrame->page()->d->client->pluginParent());
if (parentWidget) // don't reparent to nothing (i.e. keep whatever parent QWebPage::createPlugin() chose.
widget->setParent(parentWidget);
widget->hide();
RefPtr<QtPluginWidget> w = adoptRef(new QtPluginWidget());
w->setPlatformWidget(widget);
// Make sure it's invisible until properly placed into the layout
w->setFrameRect(IntRect(0, 0, 0, 0));
return w;
}
#if QT_VERSION >= 0x040600
QGraphicsWidget* graphicsWidget = qobject_cast<QGraphicsWidget*>(object);
if (graphicsWidget) {
QGraphicsObject* parentWidget = 0;
if (m_webFrame->page()->d->client)
parentWidget = qobject_cast<QGraphicsObject*>(m_webFrame->page()->d->client->pluginParent());
graphicsWidget->hide();
if (parentWidget) // don't reparent to nothing (i.e. keep whatever parent QWebPage::createPlugin() chose.
graphicsWidget->setParentItem(parentWidget);
RefPtr<QtPluginGraphicsWidget> w = QtPluginGraphicsWidget::create(graphicsWidget);
// Make sure it's invisible until properly placed into the layout
w->setFrameRect(IntRect(0, 0, 0, 0));
return w;
}
#endif
// FIXME: make things work for widgetless plugins as well
delete object;
} else { // NPAPI Plugins
Vector<String> params = paramNames;
Vector<String> values = paramValues;
if (mimeType == "application/x-shockwave-flash") {
QWebPageClient* client = m_webFrame->page()->d->client;
const bool isQWebView = client && qobject_cast<QWidget*>(client->pluginParent());
#if defined(MOZ_PLATFORM_MAEMO) && (MOZ_PLATFORM_MAEMO == 5)
size_t wmodeIndex = params.find("wmode");
if (wmodeIndex == -1) {
// Disable XEmbed mode and force it to opaque mode
params.append("wmode");
values.append("opaque");
} else if (!isQWebView) {
// Disable transparency if client is not a QWebView
values[wmodeIndex] = "opaque";
}
#else
if (!isQWebView) {
// inject wmode=opaque when there is no client or the client is not a QWebView
size_t wmodeIndex = params.find("wmode");
if (wmodeIndex == -1) {
params.append("wmode");
values.append("opaque");
} else
values[wmodeIndex] = "opaque";
}
#endif
}
RefPtr<PluginView> pluginView = PluginView::create(m_frame, pluginSize, element, url,
params, values, mimeType, loadManually);
return pluginView;
}
return 0;
}
void ProjectSettings::_update_translations() {
//update translations
if (updating_translations)
return;
updating_translations=true;
translation_list->clear();
TreeItem *root = translation_list->create_item(NULL);
translation_list->set_hide_root(true);
if (Globals::get_singleton()->has("locale/translations")) {
StringArray translations = Globals::get_singleton()->get("locale/translations");
for(int i=0;i<translations.size();i++) {
TreeItem *t = translation_list->create_item(root);
t->set_editable(0,false);
t->set_text(0,translations[i].replace_first("res://",""));
t->set_tooltip(0,translations[i]);
t->set_metadata(0,i);
t->add_button(0,get_icon("Del","EditorIcons"),0);
}
}
//update translation remaps
String remap_selected;
if (translation_remap->get_selected()) {
remap_selected = translation_remap->get_selected()->get_metadata(0);
}
translation_remap->clear();
translation_remap_options->clear();
root = translation_remap->create_item(NULL);
TreeItem *root2 = translation_remap_options->create_item(NULL);
translation_remap->set_hide_root(true);
translation_remap_options->set_hide_root(true);
translation_res_option_add_button->set_disabled(true);
Vector<String> langs = TranslationServer::get_all_locales();
Vector<String> names = TranslationServer::get_all_locale_names();
String langnames;
for(int i=0;i<names.size();i++) {
if (i>0)
langnames+=",";
langnames+=names[i];
}
if (Globals::get_singleton()->has("locale/translation_remaps")) {
Dictionary remaps = Globals::get_singleton()->get("locale/translation_remaps");
List<Variant> rk;
remaps.get_key_list(&rk);
Vector<String> keys;
for(List<Variant>::Element *E=rk.front();E;E=E->next()) {
keys.push_back(E->get());
}
keys.sort();
for(int i=0;i<keys.size();i++) {
TreeItem *t = translation_remap->create_item(root);
t->set_editable(0,false);
t->set_text(0,keys[i].replace_first("res://",""));
t->set_tooltip(0,keys[i]);
t->set_metadata(0,keys[i]);
t->add_button(0,get_icon("Del","EditorIcons"),0);
if (keys[i]==remap_selected) {
t->select(0);
translation_res_option_add_button->set_disabled(false);
StringArray selected = remaps[keys[i]];
for(int j=0;j<selected.size();j++) {
String s = selected[j];
int qp = s.find_last(":");
String path = s.substr(0,qp);
String locale = s.substr(qp+1,s.length());
TreeItem *t2 = translation_remap_options->create_item(root2);
t2->set_editable(0,false);
t2->set_text(0,path.replace_first("res://",""));
t2->set_tooltip(0,path);
t2->set_metadata(0,j);
t2->add_button(0,get_icon("Del","EditorIcons"),0);
t2->set_cell_mode(1,TreeItem::CELL_MODE_RANGE);
t2->set_text(1,langnames);
t2->set_editable(1,true);
t2->set_metadata(1,path);
int idx = langs.find(locale);
if (idx<0)
idx=0;
t2->set_range(1,idx);
}
}
}
}
updating_translations=false;
}
void TemplateVectorPerfTest::generateTestFunctions()
{
auto createVector = [this](){
Vector<Node*> ret;
for( int i=0; i<quantityOfNodes; ++i)
{
auto node = Node::create();
node->setTag(i);
ret.pushBack(node);
}
return ret;
};
TestFunction testFunctions[] = {
{ "pushBack", [=](){
Vector<Node*> nodeVector;
CC_PROFILER_START(this->profilerName());
for( int i=0; i<quantityOfNodes; ++i)
nodeVector.pushBack(Node::create());
CC_PROFILER_STOP(this->profilerName());
} } ,
{ "insert", [=](){
Vector<Node*> nodeVector;
CC_PROFILER_START(this->profilerName());
for( int i=0; i<quantityOfNodes; ++i)
nodeVector.insert(0, Node::create());
CC_PROFILER_STOP(this->profilerName());
} } ,
{ "replace", [=](){
Vector<Node*> nodeVector = createVector();
srand((unsigned)time(nullptr));
ssize_t index = rand() % quantityOfNodes;
CC_PROFILER_START(this->profilerName());
for( int i=0; i<quantityOfNodes; ++i)
nodeVector.replace(index, Node::create());
CC_PROFILER_STOP(this->profilerName());
} } ,
{ "getIndex", [=](){
Vector<Node*> nodeVector = createVector();
Node* objToGet = nodeVector.at(quantityOfNodes/3);
ssize_t index = 0;
CC_PROFILER_START(this->profilerName());
for( int i=0; i<quantityOfNodes; ++i)
index = nodeVector.getIndex(objToGet);
CC_PROFILER_STOP(this->profilerName());
// Uses `index` to avoids `getIndex` invoking was optimized in release mode
if (index == quantityOfNodes/3)
{
nodeVector.clear();
}
} } ,
{ "find", [=](){
Vector<Node*> nodeVector = createVector();
Node* objToGet = nodeVector.at(quantityOfNodes/3);
Vector<Node*>::iterator iter;
CC_PROFILER_START(this->profilerName());
for( int i=0; i<quantityOfNodes; ++i)
iter = nodeVector.find(objToGet);
CC_PROFILER_STOP(this->profilerName());
// Uses `iter` to avoids `find` invoking was optimized in release mode
if (*iter == objToGet)
{
nodeVector.clear();
}
} } ,
{ "at", [=](){
Vector<Node*> nodeVector = createVector();
Node* objToGet = nullptr;
CC_PROFILER_START(this->profilerName());
for( int i=0; i<quantityOfNodes; ++i)
objToGet = nodeVector.at(quantityOfNodes/3);
CC_PROFILER_STOP(this->profilerName());
// Uses `objToGet` to avoids `at` invoking was optimized in release mode
if (nodeVector.getIndex(objToGet) == quantityOfNodes/3)
{
nodeVector.clear();
}
} } ,
{ "contains", [=](){
Vector<Node*> nodeVector = createVector();
Node* objToGet = nodeVector.at(quantityOfNodes/3);
bool ret = false;
CC_PROFILER_START(this->profilerName());
for( int i=0; i<quantityOfNodes; ++i)
ret = nodeVector.contains(objToGet);
CC_PROFILER_STOP(this->profilerName());
// Uses `ret` to avoids `contains` invoking was optimized in release mode
if (ret)
{
nodeVector.clear();
}
} } ,
{ "eraseObject", [=](){
Vector<Node*> nodeVector = createVector();
Node** nodes = (Node**)malloc(sizeof(Node*) * quantityOfNodes);
for (int i = 0; i < quantityOfNodes; ++i)
{
nodes[i] = nodeVector.at(i);
}
CC_PROFILER_START(this->profilerName());
for( int i=0; i<quantityOfNodes; ++i)
nodeVector.eraseObject(nodes[i]);
CC_PROFILER_STOP(this->profilerName());
CCASSERT(nodeVector.empty(), "nodeVector was not empty.");
free(nodes);
} } ,
{ "erase", [=](){
Vector<Node*> nodeVector = createVector();
CC_PROFILER_START(this->profilerName());
for( int i=0; i<quantityOfNodes; ++i)
nodeVector.erase(nodeVector.begin());
CC_PROFILER_STOP(this->profilerName());
CCASSERT(nodeVector.empty(), "nodeVector was not empty.");
} } ,
{ "clear", [=](){
Vector<Node*> nodeVector = createVector();
CC_PROFILER_START(this->profilerName());
for( int i=0; i<quantityOfNodes; ++i)
nodeVector.clear();
CC_PROFILER_STOP(this->profilerName());
CCASSERT(nodeVector.empty(), "nodeVector was not empty.");
} } ,
{ "swap by index", [=](){
Vector<Node*> nodeVector = createVector();
int swapIndex1 = quantityOfNodes / 3;
int swapIndex2 = quantityOfNodes / 3 * 2;
CC_PROFILER_START(this->profilerName());
for( int i=0; i<quantityOfNodes; ++i)
nodeVector.swap(swapIndex1, swapIndex2);
CC_PROFILER_STOP(this->profilerName());
} } ,
{ "swap by object", [=](){
Vector<Node*> nodeVector = createVector();
Node* swapNode1 = nodeVector.at(quantityOfNodes / 3);
Node* swapNode2 = nodeVector.at(quantityOfNodes / 3 * 2);
CC_PROFILER_START(this->profilerName());
for( int i=0; i<quantityOfNodes; ++i)
nodeVector.swap(swapNode1, swapNode2);
CC_PROFILER_STOP(this->profilerName());
} } ,
{ "reverse", [=](){
Vector<Node*> nodeVector = createVector();
CC_PROFILER_START(this->profilerName());
for( int i=0; i<quantityOfNodes; ++i)
nodeVector.reverse();
CC_PROFILER_STOP(this->profilerName());
} } ,
{ "c++11 Range Loop", [=](){
Vector<Node*> nodeVector = createVector();
CC_PROFILER_START(this->profilerName());
for (const auto& e : nodeVector)
{
e->setTag(111);
}
CC_PROFILER_STOP(this->profilerName());
} } ,
};
for (const auto& func : testFunctions)
{
_testFunctions.push_back(func);
}
}
