array.cpp | Explore in Territory

/**************************************************************************/
/*  array.cpp                                                             */
/**************************************************************************/
/*                         This file is part of:                          */
/*                             GODOT ENGINE                               */
/*                        https://godotengine.org                         */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
/*                                                                        */
/* Permission is hereby granted, free of charge, to any person obtaining  */
/* a copy of this software and associated documentation files (the        */
/* "Software"), to deal in the Software without restriction, including    */
/* without limitation the rights to use, copy, modify, merge, publish,    */
/* distribute, sublicense, and/or sell copies of the Software, and to     */
/* permit persons to whom the Software is furnished to do so, subject to  */
/* the following conditions:                                              */
/*                                                                        */
/* The above copyright notice and this permission notice shall be         */
/* included in all copies or substantial portions of the Software.        */
/*                                                                        */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
/**************************************************************************/

#include "array.h"

#include "container_type_validate.h"
#include "core/math/math_funcs.h"
#include "core/object/class_db.h"
#include "core/object/script_language.h"
#include "core/templates/hashfuncs.h"
#include "core/templates/search_array.h"
#include "core/templates/vector.h"
#include "core/variant/callable.h"
#include "core/variant/dictionary.h"
#include "core/variant/variant.h"

class ArrayPrivate { … };

void Array::_ref(const Array &p_from) const { … }

void Array::_unref() const { … }

Array::Iterator Array::begin() { … }

Array::Iterator Array::end() { … }

Array::ConstIterator Array::begin() const { … }

Array::ConstIterator Array::end() const { … }

Variant &Array::operator[](int p_idx) { … }

const Variant &Array::operator[](int p_idx) const { … }

int Array::size() const { … }

bool Array::is_empty() const { … }

void Array::clear() { … }

bool Array::operator==(const Array &p_array) const { … }

bool Array::operator!=(const Array &p_array) const { … }

bool Array::recursive_equal(const Array &p_array, int recursion_count) const { … }

bool Array::operator<(const Array &p_array) const { … }

bool Array::operator<=(const Array &p_array) const { … }
bool Array::operator>(const Array &p_array) const { … }
bool Array::operator>=(const Array &p_array) const { … }

uint32_t Array::hash() const { … }

uint32_t Array::recursive_hash(int recursion_count) const { … }

void Array::operator=(const Array &p_array) { … }

void Array::assign(const Array &p_array) { … }

void Array::push_back(const Variant &p_value) { … }

void Array::append_array(const Array &p_array) { … }

Error Array::resize(int p_new_size) { … }

Error Array::insert(int p_pos, const Variant &p_value) { … }

void Array::fill(const Variant &p_value) { … }

void Array::erase(const Variant &p_value) { … }

Variant Array::front() const { … }

Variant Array::back() const { … }

Variant Array::pick_random() const { … }

int Array::find(const Variant &p_value, int p_from) const { … }

int Array::find_custom(const Callable &p_callable, int p_from) const { … }

int Array::rfind(const Variant &p_value, int p_from) const { … }

int Array::rfind_custom(const Callable &p_callable, int p_from) const { … }

int Array::count(const Variant &p_value) const { … }

bool Array::has(const Variant &p_value) const { … }

void Array::remove_at(int p_pos) { … }

void Array::set(int p_idx, const Variant &p_value) { … }

const Variant &Array::get(int p_idx) const { … }

Array Array::duplicate(bool p_deep) const { … }

Array Array::recursive_duplicate(bool p_deep, int recursion_count) const { … }

Array Array::slice(int p_begin, int p_end, int p_step, bool p_deep) const { … }

Array Array::filter(const Callable &p_callable) const { … }

Array Array::map(const Callable &p_callable) const { … }

Variant Array::reduce(const Callable &p_callable, const Variant &p_accum) const { … }

bool Array::any(const Callable &p_callable) const { … }

bool Array::all(const Callable &p_callable) const { … }

struct _ArrayVariantSort { … };

void Array::sort() { … }

void Array::sort_custom(const Callable &p_callable) { … }

void Array::shuffle() { … }

int Array::bsearch(const Variant &p_value, bool p_before) const { … }

int Array::bsearch_custom(const Variant &p_value, const Callable &p_callable, bool p_before) const { … }

void Array::reverse() { … }

void Array::push_front(const Variant &p_value) { … }

Variant Array::pop_back() { … }

Variant Array::pop_front() { … }

Variant Array::pop_at(int p_pos) { … }

Variant Array::min() const { … }

Variant Array::max() const { … }

const void *Array::id() const { … }

Array::Array(const Array &p_from, uint32_t p_type, const StringName &p_class_name, const Variant &p_script) { … }

void Array::set_typed(uint32_t p_type, const StringName &p_class_name, const Variant &p_script) { … }

bool Array::is_typed() const { … }

bool Array::is_same_typed(const Array &p_other) const { … }

bool Array::is_same_instance(const Array &p_other) const { … }

uint32_t Array::get_typed_builtin() const { … }

StringName Array::get_typed_class_name() const { … }

Variant Array::get_typed_script() const { … }

Array Array::create_read_only() { … }

void Array::make_read_only() { … }

bool Array::is_read_only() const { … }

Array::Array(const Array &p_from) { … }

Array::Array() { … }

Array::~Array() { … }
godot/core/variant/array.cpp
