return PyBytes_Check(o) ||

#if PY_MAJOR_VERSION < 3

PyString_Check(o) ||

#endif

PyUnicode_Check(o);

// __class__ is equivalent to type() for new style classes.

// type() is equivalent to PyObject_Type()

// (https://docs.python.org/3.5/c-api/object.html#c.PyObject_Type)

// PyObject_Type() is equivalent to o->ob_type except for Py_INCREF, which

// we don't need here.

PyTypeObject* type = o->ob_type;

// __name__ is the value of `tp_name` after the last '.'

// (https://docs.python.org/2/c-api/typeobj.html#c.PyTypeObject.tp_name)

StringPiece name(type->tp_name);

size_t pos = name.rfind('.');

if (pos != StringPiece::npos) {

name.remove_prefix(pos + 1);

}

return name;

if (o == nullptr) {

return "<null object>";

}

PyObject* str = PyObject_Str(o);

if (str) {

#if PY_MAJOR_VERSION < 3

string s(PyString_AS_STRING(str));

#else

string s(PyUnicode_AsUTF8(str));

#endif

Py_DECREF(str);

return tensorflow::strings::StrCat("type=", GetClassName(o), " str=", s);

} else {

return "<failed to execute str() on object>";

}

public:

explicit CachedTypeCheck(std::function<int(PyObject*)> ternary_predicate)

: ternary_predicate_(std::move(ternary_predicate)) {}

~CachedTypeCheck() {

mutex_lock l(type_to_sequence_map_mu_);

for (const auto& pair : type_to_sequence_map_) {

Py_DECREF(pair.first);

}

}

// Caches successful executions of the one-argument (PyObject*) callable

// "ternary_predicate" based on the type of "o". -1 from the callable

// indicates an unsuccessful check (not cached), 0 indicates that "o"'s type

// does not match the predicate, and 1 indicates that it does. Used to avoid

// calling back into Python for expensive isinstance checks.

int CachedLookup(PyObject* o) {

// Try not to return to Python - see if the type has already been seen

// before.

auto* type = Py_TYPE(o);

{

tf_shared_lock l(type_to_sequence_map_mu_);

auto it = type_to_sequence_map_.find(type);

if (it != type_to_sequence_map_.end()) {

return it->second;

}

}

int check_result = ternary_predicate_(o);

if (check_result == -1) {

return -1; // Type check error, not cached.

}

// NOTE: This is never decref'd as long as the object lives, which is likely

// forever, but we don't want the type to get deleted as long as it is in

// the map. This should not be too much of a leak, as there should only be a

// relatively small number of types in the map, and an even smaller number

// that are eligible for decref. As a precaution, we limit the size of the

// map to 1024.

{

mutex_lock l(type_to_sequence_map_mu_);

if (type_to_sequence_map_.size() < kMaxItemsInCache) {

Py_INCREF(type);

auto insert_result = type_to_sequence_map_.insert({type, check_result});

if (!insert_result.second) {

// The type was added to the cache by a concurrent thread after we

// looked it up above.

Py_DECREF(type);

}

}

}

return check_result;

}

private:

std::function<int(PyObject*)> ternary_predicate_;

mutex type_to_sequence_map_mu_;

std::unordered_map<PyTypeObject*, bool> type_to_sequence_map_

TF_GUARDED_BY(type_to_sequence_map_mu_);

const char* type_name) {

PyObject* given_type = ImportTypeFromModule(module_name, type_name);

if (TF_PREDICT_FALSE(given_type == nullptr)) {

return false;

}

return PyObject_IsInstance(obj, given_type);

static auto* const check_cache = new CachedTypeCheck([](PyObject* to_check) {

return IsInstanceOfGivenType(to_check, "collections.abc", "Mapping");

});

if (PyDict_Check(o)) return true;

return check_cache->CachedLookup(o);

static auto* const check_cache = new CachedTypeCheck([](PyObject* to_check) {

return IsInstanceOfGivenType(to_check, "collections.abc", "MutableMapping");

});

if (PyDict_Check(o)) return true;

return check_cache->CachedLookup(o);

static auto* const check_cache = new CachedTypeCheck([](PyObject* to_check) {

return IsInstanceOfGivenType(to_check, "collections.abc", "MappingView");

});

return check_cache->CachedLookup(o);

static auto* const check_cache = new CachedTypeCheck([](PyObject* to_check) {

return IsInstanceOfGivenType(to_check, "wrapt", "ObjectProxy");

});

return check_cache->CachedLookup(o);

static auto* const check_cache = new CachedTypeCheck([](PyObject* to_check) {

Safe_PyObjectPtr cls(PyObject_GetAttrString(to_check, "__class__"));

if (cls) {

return PyObject_HasAttrString(cls.get(), "__attrs_attrs__");

}

// PyObject_GetAttrString returns null on error

PyErr_Clear();

return 0;

});

return check_cache->CachedLookup(o);

static auto* const check_cache = new CachedTypeCheck([](PyObject* to_check) {

Safe_PyObjectPtr cls(PyObject_GetAttrString(to_check, "__class__"));

if (cls) {

return PyObject_HasAttrString(cls.get(), "__tf_flatten__") &

PyObject_HasAttrString(cls.get(), "__tf_unflatten__");

}

// PyObject_GetAttrString returns null on error

PyErr_Clear();

return 0;

});

return check_cache->CachedLookup(o);

static auto* const check_cache = new CachedTypeCheck([](PyObject* to_check) {

return IsInstanceOfGivenType(to_check, INDEXED_SLICES_MODULE,

"IndexedSlices");

});

return check_cache->CachedLookup(o);

static auto* const check_cache = new CachedTypeCheck([](PyObject* to_check) {

return IsInstanceOfGivenType(to_check, TENSOR_MODULE, "Tensor");

});

return check_cache->CachedLookup(o);

static auto* const check_cache = new CachedTypeCheck([](PyObject* to_check) {

return IsInstanceOfGivenType(to_check, TENSOR_MODULE, "TensorSpec");

});

return check_cache->CachedLookup(o);

static auto* const check_cache = new CachedTypeCheck([](PyObject* to_check) {

return IsInstanceOfGivenType(to_check, OPS_MODULE, "EagerTensor");

});

return check_cache->CachedLookup(o);

static auto* const check_cache = new CachedTypeCheck([](PyObject* to_check) {

return IsInstanceOfGivenType(to_check, CORE_TYPES_MODULE, "TensorProtocol");

});

return check_cache->CachedLookup(o);

static auto* const check_cache = new CachedTypeCheck([](PyObject* to_check) {

return IsInstanceOfGivenType(to_check, CORE_TYPES_MODULE, "Value");

});

return check_cache->CachedLookup(o);

static auto* const check_cache = new CachedTypeCheck([](PyObject* to_check) {

return IsInstanceOfGivenType(to_check, RESOURCE_VAR_MODULE,

"ResourceVariable");

});

return check_cache->CachedLookup(o);

static auto* const check_cache = new CachedTypeCheck([](PyObject* to_check) {

return IsInstanceOfGivenType(to_check, ITERATOR_OPS_MODULE,

"OwnedIterator");

});

return check_cache->CachedLookup(o);

static auto* const check_cache = new CachedTypeCheck([](PyObject* to_check) {

return IsInstanceOfGivenType(to_check, VARIABLES_MODULE, "Variable");

});

return check_cache->CachedLookup(o);

// We treat dicts and other mappings as special cases of sequences.

if (IsMappingHelper(o)) return true;

if (IsMappingViewHelper(o)) return true;

if (IsAttrsHelper(o)) return true;

if (IsCustomNestProtocolDefined(o)) return true;

static auto* const check_cache = new CachedTypeCheck([](PyObject* to_check) {

int is_instance =

IsInstanceOfGivenType(to_check, "collections.abc", "Sequence");

// Don't cache a failed is_instance check.

if (is_instance == -1) return -1;

return static_cast<int>(is_instance != 0 && !IsString(to_check));

});

return check_cache->CachedLookup(o);

static auto* const check_cache = new CachedTypeCheck([](PyObject* to_check) {

return PyObject_HasAttrString(

reinterpret_cast<PyObject*>(to_check->ob_type), "__tf_dispatch__");

});

return check_cache->CachedLookup(o);

public:

virtual ~ValueIterator() {}

virtual Safe_PyObjectPtr next() = 0;

bool valid() const { return is_valid_; }

protected:

void invalidate() { is_valid_ = false; }

private:

bool is_valid_ = true;

public:

explicit DictValueIterator(PyObject* dict)

: dict_(dict), keys_(PyDict_Keys(dict)) {

if (PyList_Sort(keys_.get()) == -1) {

invalidate();

} else {

iter_.reset(PyObject_GetIter(keys_.get()));

}

}

Safe_PyObjectPtr next() override {

Safe_PyObjectPtr result;

Safe_PyObjectPtr key(PyIter_Next(iter_.get()));

if (key) {

// PyDict_GetItem returns a borrowed reference.

PyObject* elem = PyDict_GetItem(dict_, key.get());

if (elem) {

Py_INCREF(elem);

result.reset(elem);

} else {

PyErr_SetString(PyExc_RuntimeError,

"Dictionary was modified during iteration over it");

}

}

return result;

}

private:

PyObject* dict_;

Safe_PyObjectPtr keys_;

Safe_PyObjectPtr iter_;

public:

explicit MappingValueIterator(PyObject* mapping)

: mapping_(mapping), keys_(MappingKeys(mapping)) {

if (!keys_ || PyList_Sort(keys_.get()) == -1) {

invalidate();

} else {

iter_.reset(PyObject_GetIter(keys_.get()));

}

}

Safe_PyObjectPtr next() override {

Safe_PyObjectPtr result;

Safe_PyObjectPtr key(PyIter_Next(iter_.get()));

if (key) {

// Unlike PyDict_GetItem, PyObject_GetItem returns a new reference.

PyObject* elem = PyObject_GetItem(mapping_, key.get());

if (elem) {

result.reset(elem);

} else {

PyErr_SetString(PyExc_RuntimeError,

"Mapping was modified during iteration over it");

}

}

return result;

}

private:

PyObject* mapping_;

Safe_PyObjectPtr keys_;

Safe_PyObjectPtr iter_;

public:

explicit SequenceValueIterator(PyObject* iterable)

: seq_(PySequence_Fast(iterable, "")),

size_(seq_.get() ? PySequence_Fast_GET_SIZE(seq_.get()) : 0),

index_(0) {}

Safe_PyObjectPtr next() override {

Safe_PyObjectPtr result;

if (index_ < size_) {

// PySequence_Fast_GET_ITEM returns a borrowed reference.

PyObject* elem = PySequence_Fast_GET_ITEM(seq_.get(), index_);

++index_;

if (elem) {

Py_INCREF(elem);

result.reset(elem);

}

}

return result;

}

private:

Safe_PyObjectPtr seq_;

const Py_ssize_t size_;

Py_ssize_t index_;

public:

explicit SingleValueIterator(PyObject* x) : x_(x) { Py_INCREF(x); }

Safe_PyObjectPtr next() override { return std::move(x_); }

private:

Safe_PyObjectPtr x_;

public:

ErrorValueIterator() {}

Safe_PyObjectPtr next() override { return nullptr; }

public:

explicit AttrsValueIterator(PyObject* nested) : nested_(nested) {

Py_INCREF(nested);

cls_.reset(PyObject_GetAttrString(nested_.get(), "__class__"));

if (cls_) {

attrs_.reset(PyObject_GetAttrString(cls_.get(), "__attrs_attrs__"));

if (attrs_) {

iter_.reset(PyObject_GetIter(attrs_.get()));

}

}

if (!iter_ || PyErr_Occurred()) invalidate();

}

Safe_PyObjectPtr next() override {

Safe_PyObjectPtr result;

Safe_PyObjectPtr item(PyIter_Next(iter_.get()));

if (item) {

Safe_PyObjectPtr name(PyObject_GetAttrString(item.get(), "name"));

result.reset(PyObject_GetAttr(nested_.get(), name.get()));

}

return result;

}

private:

Safe_PyObjectPtr nested_;

Safe_PyObjectPtr cls_;

Safe_PyObjectPtr attrs_;

Safe_PyObjectPtr iter_;

public:

explicit CustomNestedIterator(PyObject* nested) : nested_(nested) {

Py_INCREF(nested);

flattened_.reset(

PyObject_CallMethod(nested_.get(), "__tf_flatten__", nullptr));

if (flattened_) {

Safe_PyObjectPtr seq = make_safe(PySequence_GetItem(flattened_.get(), 1));

if (seq) {

iter_.reset(PyObject_GetIter(seq.get()));

}

}

if (!iter_ || PyErr_Occurred()) invalidate();

}

Safe_PyObjectPtr next() override {

Safe_PyObjectPtr result(PyIter_Next(iter_.get()));

return result;

}

private:

Safe_PyObjectPtr nested_;

Safe_PyObjectPtr flattened_;

Safe_PyObjectPtr iter_;

PyObject* sparse_tensor_value_type =

ImportTypeFromModule(SPARSE_TENSOR_MODULE, "SparseTensorValue");

if (TF_PREDICT_FALSE(sparse_tensor_value_type == nullptr)) {

return false;

}

return PyObject_TypeCheck(

o, reinterpret_cast<PyTypeObject*>(sparse_tensor_value_type)) == 1;

static auto* const check_cache = new CachedTypeCheck([](PyObject* to_check) {

// TODO(b/246438937): Remove the ResourceVariable test.

return IsInstanceOfGivenType(to_check, COMPOSITE_TENSOR_MODULE,

"CompositeTensor") &&

!IsResourceVariable(to_check);

});

return check_cache->CachedLookup(o);

static auto* const check_cache = new CachedTypeCheck([](PyObject* to_check) {

int is_type_spec =

IsInstanceOfGivenType(to_check, TYPE_SPEC_MODULE, "TypeSpec");

// TODO(b/246438937): Remove the VariableSpec special case.

int is_dense_spec =

(IsInstanceOfGivenType(to_check, TENSOR_MODULE, "TensorSpec") ||

IsInstanceOfGivenType(to_check, RESOURCE_VAR_MODULE, "VariableSpec"));

if ((is_type_spec == -1) || (is_dense_spec == -1)) return -1;

return static_cast<int>(is_type_spec && !is_dense_spec);

});

return check_cache->CachedLookup(o);

int is_nested = IsNestedHelper(o);

int is_composite = IsCompositeTensorHelper(o);

int is_type_spec = IsTypeSpecHelper(o);

if ((is_nested == -1) || (is_composite == -1) || (is_type_spec == -1)) {

return -1;

}

return is_nested || is_composite || is_type_spec;

if (PyDict_Check(nested)) {

return absl::make_unique<DictValueIterator>(nested);

} else if (IsMappingHelper(nested)) {

return absl::make_unique<MappingValueIterator>(nested);

} else if (IsAttrsHelper(nested)) {

return absl::make_unique<AttrsValueIterator>(nested);

} else if (IsCustomNestProtocolDefined(nested)) {

return std::make_unique<CustomNestedIterator>(nested);

} else {

return absl::make_unique<SequenceValueIterator>(nested);

}

if (PyDict_Check(nested)) {

return absl::make_unique<DictValueIterator>(nested);

} else if (IsMappingHelper(nested)) {

return absl::make_unique<MappingValueIterator>(nested);

} else if (IsAttrsHelper(nested)) {

return absl::make_unique<AttrsValueIterator>(nested);

} else if (IsSparseTensorValueType(nested)) {

return absl::make_unique<SingleValueIterator>(nested);

} else if (IsCustomNestProtocolDefined(nested)) {

return std::make_unique<CustomNestedIterator>(nested);

} else {

return absl::make_unique<SequenceValueIterator>(nested);

}

if (IsCompositeTensor(nested)) {

Safe_PyObjectPtr spec(PyObject_GetAttrString(nested, "_type_spec"));

if (PyErr_Occurred() || !spec) {

return absl::make_unique<ErrorValueIterator>();

}

static char to_components[] = "_to_components";

static char argspec[] = "(O)";

Safe_PyObjectPtr components(

PyObject_CallMethod(spec.get(), to_components, argspec, nested));

if (PyErr_Occurred() || components == nullptr) {

return absl::make_unique<ErrorValueIterator>();

}

return absl::make_unique<SingleValueIterator>(components.get());

}

if (IsTypeSpec(nested)) {

Safe_PyObjectPtr specs(PyObject_GetAttrString(nested, "_component_specs"));

if (PyErr_Occurred() || specs == nullptr) {

return absl::make_unique<ErrorValueIterator>();

}

return absl::make_unique<SingleValueIterator>(specs.get());

}

return GetValueIterator(nested);

PyObject* nested, PyObject* list,

const std::function<int(PyObject*)>& is_nested_helper,

const std::function<ValueIteratorPtr(PyObject*)>& value_iterator_getter) {

// if nested is not a sequence, append itself and exit

int is_nested = is_nested_helper(nested);

if (is_nested == -1) return false;

if (!is_nested) {

return PyList_Append(list, nested) != -1;

}

ValueIteratorPtr iter = value_iterator_getter(nested);

if (!iter->valid()) return false;

for (Safe_PyObjectPtr item = iter->next(); item; item = iter->next()) {

if (Py_EnterRecursiveCall(" in flatten")) {

return false;

}

const bool success = FlattenHelper(item.get(), list, is_nested_helper,

value_iterator_getter);

Py_LeaveRecursiveCall();

if (!success) {

return false;

}

}

return true;

bool* is_type_error) {

Safe_PyObjectPtr k1(MappingKeys(dict1));

if (PyErr_Occurred() || k1.get() == nullptr) {

*error_msg =

("The two dictionaries don't have the same set of keys. Failed to "

"fetch keys.");

return;

}

Safe_PyObjectPtr k2(MappingKeys(dict2));

if (PyErr_Occurred() || k2.get() == nullptr) {

*error_msg =

("The two dictionaries don't have the same set of keys. Failed to "

"fetch keys.");

return;

}

*is_type_error = false;

*error_msg = tensorflow::strings::StrCat(

"The two dictionaries don't have the same set of keys. "

"First structure has keys ",

PyObjectToString(k1.get()), ", while second structure has keys ",

PyObjectToString(k2.get()));

PyObject* o1, PyObject* o2, bool check_types, string* error_msg,

bool* is_type_error, const std::function<int(PyObject*)>& is_nested_helper,

const std::function<ValueIteratorPtr(PyObject*)>& value_iterator_getter,

bool check_composite_tensor_type_spec) {

DCHECK(error_msg);

DCHECK(is_type_error);

const bool is_nested1 = is_nested_helper(o1);

const bool is_nested2 = is_nested_helper(o2);

if (PyErr_Occurred()) return false;

if (is_nested1 != is_nested2) {

string seq_str = is_nested1 ? PyObjectToString(o1) : PyObjectToString(o2);

string non_seq_str =

is_nested1 ? PyObjectToString(o2) : PyObjectToString(o1);

*is_type_error = false;

*error_msg = tensorflow::strings::StrCat(

"Substructure \"", seq_str, "\" is a sequence, while substructure \"",

non_seq_str, "\" is not");

return true;

}

// Got to objects that are considered non-sequences. Note that in tf.data

// use case lists and sparse_tensors are not considered sequences. So finished

// checking, structures are the same.

if (!is_nested1) return true;

if (check_types) {

// Treat wrapped tuples as tuples.

tensorflow::Safe_PyObjectPtr o1_wrapped;

if (IsObjectProxy(o1)) {

o1_wrapped.reset(PyObject_GetAttrString(o1, "__wrapped__"));

o1 = o1_wrapped.get();

}

tensorflow::Safe_PyObjectPtr o2_wrapped;

if (IsObjectProxy(o2)) {

o2_wrapped.reset(PyObject_GetAttrString(o2, "__wrapped__"));

o2 = o2_wrapped.get();

}

const PyTypeObject* type1 = o1->ob_type;

const PyTypeObject* type2 = o2->ob_type;

// We treat two different namedtuples with identical name and fields

// as having the same type.

const PyObject* o1_tuple = IsNamedtuple(o1, false);

if (o1_tuple == nullptr) return false;

const PyObject* o2_tuple = IsNamedtuple(o2, false);

if (o2_tuple == nullptr) {

Py_DECREF(o1_tuple);

return false;

}

bool both_tuples = o1_tuple == Py_True && o2_tuple == Py_True;

Py_DECREF(o1_tuple);

Py_DECREF(o2_tuple);

if (both_tuples) {

const PyObject* same_tuples = SameNamedtuples(o1, o2);

if (same_tuples == nullptr) return false;

bool not_same_tuples = same_tuples != Py_True;

Py_DECREF(same_tuples);

if (not_same_tuples) {

*is_type_error = true;

*error_msg = tensorflow::strings::StrCat(

"The two namedtuples don't have the same sequence type. "

"First structure ",

PyObjectToString(o1), " has type ", type1->tp_name,

", while second structure ", PyObjectToString(o2), " has type ",

type2->tp_name);

return true;

}

} else if (type1 != type2

/* If both sequences are list types, don't complain. This allows

&& !(PyList_Check(o1) && PyList_Check(o2))

/* Two mapping types will also compare equal, making _DictWrapper

&& !(IsMappingHelper(o1) && IsMappingHelper(o2))

/* For CompositeTensor & TypeSpec, we check below. */

&& !(check_composite_tensor_type_spec &&

(IsCompositeTensor(o1) || IsTypeSpec(o1)) &&

(IsCompositeTensor(o2) || IsTypeSpec(o2)))) {

*is_type_error = true;

*error_msg = tensorflow::strings::StrCat(

"The two namedtuples don't have the same sequence type. "

"First structure ",

PyObjectToString(o1), " has type ", type1->tp_name,

", while second structure ", PyObjectToString(o2), " has type ",

type2->tp_name);

return true;

}

if (PyDict_Check(o1) && PyDict_Check(o2)) {

if (PyDict_Size(o1) != PyDict_Size(o2)) {

SetDifferentKeysError(o1, o2, error_msg, is_type_error);

return true;

}

PyObject* key;

Py_ssize_t pos = 0;

while (PyDict_Next(o1, &pos, &key, nullptr)) {

if (PyDict_GetItem(o2, key) == nullptr) {

SetDifferentKeysError(o1, o2, error_msg, is_type_error);

return true;

}

}

} else if (IsMappingHelper(o1)) {

// Fallback for custom mapping types. Instead of using PyDict methods

// which stay in C, we call iter(o1).

if (PyMapping_Size(o1) != PyMapping_Size(o2)) {

SetDifferentKeysError(o1, o2, error_msg, is_type_error);

return true;

}

Safe_PyObjectPtr iter(PyObject_GetIter(o1));

PyObject* key;

while ((key = PyIter_Next(iter.get())) != nullptr) {

if (!PyMapping_HasKey(o2, key)) {

SetDifferentKeysError(o1, o2, error_msg, is_type_error);

Py_DECREF(key);

return true;

}

Py_DECREF(key);

}

}

}

if (check_composite_tensor_type_spec &&

(IsCompositeTensor(o1) || IsCompositeTensor(o2))) {

Safe_PyObjectPtr owned_type_spec_1;

PyObject* type_spec_1 = o1;

if (IsCompositeTensor(o1)) {

owned_type_spec_1.reset(PyObject_GetAttrString(o1, "_type_spec"));

type_spec_1 = owned_type_spec_1.get();

}

Safe_PyObjectPtr owned_type_spec_2;

PyObject* type_spec_2 = o2;

if (IsCompositeTensor(o2)) {

owned_type_spec_2.reset(PyObject_GetAttrString(o2, "_type_spec"));

type_spec_2 = owned_type_spec_2.get();

}

// Two composite tensors are considered to have the same structure if

// they share a type spec that is a supertype of both of them. We do *not*

// use is_subtype_of, since that would prevent us from e.g. using a

// cond statement where the two sides have different shapes.

// TODO(b/206014848): We have to explicitly remove the names.

Safe_PyObjectPtr owned_nameless_type_spec_1(

PyObject_CallMethod(type_spec_1, "_without_tensor_names", nullptr));

Safe_PyObjectPtr owned_nameless_type_spec_2(

PyObject_CallMethod(type_spec_2, "_without_tensor_names", nullptr));

// TODO(b/222123181): Reconsider most_specific_common_supertype usage.

static char compatible_type[] = "most_specific_common_supertype";

static char argspec[] = "([O])";

Safe_PyObjectPtr struct_compatible(

PyObject_CallMethod(owned_nameless_type_spec_1.get(), compatible_type,

argspec, owned_nameless_type_spec_2.get()));

if (PyErr_Occurred()) {

return false;

}

if (struct_compatible.get() == Py_None) {

*is_type_error = false;

*error_msg = tensorflow::strings::StrCat(

"Incompatible CompositeTensor TypeSpecs: ",

PyObjectToString(type_spec_1), " vs. ",

PyObjectToString(type_spec_2));

return true;

}

}

ValueIteratorPtr iter1 = value_iterator_getter(o1);

ValueIteratorPtr iter2 = value_iterator_getter(o2);