godot/core/variant/callable.cpp

/**************************************************************************/
/*  callable.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 "callable.h"

#include "core/object/object.h"
#include "core/object/ref_counted.h"
#include "core/object/script_language.h"
#include "core/variant/callable_bind.h"
#include "core/variant/variant_callable.h"

void Callable::call_deferredp(const Variant **p_arguments, int p_argcount) const { … }

void Callable::callp(const Variant **p_arguments, int p_argcount, Variant &r_return_value, CallError &r_call_error) const { … }

Variant Callable::callv(const Array &p_arguments) const { … }

Error Callable::rpcp(int p_id, const Variant **p_arguments, int p_argcount, CallError &r_call_error) const { … }

Callable Callable::bindp(const Variant **p_arguments, int p_argcount) const { … }

Callable Callable::bindv(const Array &p_arguments) { … }

Callable Callable::unbind(int p_argcount) const { … }

bool Callable::is_valid() const { … }

Object *Callable::get_object() const { … }

ObjectID Callable::get_object_id() const { … }

StringName Callable::get_method() const { … }

int Callable::get_argument_count(bool *r_is_valid) const { … }

int Callable::get_bound_arguments_count() const { … }

void Callable::get_bound_arguments_ref(Vector<Variant> &r_arguments, int &r_argcount) const { … }

Array Callable::get_bound_arguments() const { … }

CallableCustom *Callable::get_custom() const { … }

const Callable *Callable::get_base_comparator() const { … }

uint32_t Callable::hash() const { … }

bool Callable::operator==(const Callable &p_callable) const { … }

bool Callable::operator!=(const Callable &p_callable) const { … }

bool Callable::operator<(const Callable &p_callable) const { … }

void Callable::operator=(const Callable &p_callable) { … }

operator String()

Callable Callable::create(const Variant &p_variant, const StringName &p_method) { … }

Callable::Callable(const Object *p_object, const StringName &p_method) { … }

Callable::Callable(ObjectID p_object, const StringName &p_method) { … }

Callable::Callable(CallableCustom *p_custom) { … }

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

Callable::~Callable() { … }

bool CallableCustom::is_valid() const { … }

StringName CallableCustom::get_method() const { … }

Error CallableCustom::rpc(int p_peer_id, const Variant **p_arguments, int p_argcount, Callable::CallError &r_call_error) const { … }

const Callable *CallableCustom::get_base_comparator() const { … }

int CallableCustom::get_argument_count(bool &r_is_valid) const { … }

int CallableCustom::get_bound_arguments_count() const { … }

void CallableCustom::get_bound_arguments(Vector<Variant> &r_arguments, int &r_argcount) const { … }

CallableCustom::CallableCustom() { … }

//////////////////////////////////

Object *Signal::get_object() const { … }

ObjectID Signal::get_object_id() const { … }

StringName Signal::get_name() const { … }

bool Signal::operator==(const Signal &p_signal) const { … }

bool Signal::operator!=(const Signal &p_signal) const { … }

bool Signal::operator<(const Signal &p_signal) const { … }

operator String()

Error Signal::emit(const Variant **p_arguments, int p_argcount) const { … }

Error Signal::connect(const Callable &p_callable, uint32_t p_flags) { … }

void Signal::disconnect(const Callable &p_callable) { … }

bool Signal::is_connected(const Callable &p_callable) const { … }

bool Signal::has_connections() const { … }

Array Signal::get_connections() const { … }

Signal::Signal(const Object *p_object, const StringName &p_name) { … }

Signal::Signal(ObjectID p_object, const StringName &p_name) { … }

bool CallableComparator::operator()(const Variant &p_l, const Variant &p_r) const { … }