typerig.core.objects.array

# MODULE: TypeRig / Core / Array (Objects)
# -----------------------------------------------------------
# (C) Vassil Kateliev, 2018-2020        (http://www.kateliev.com)
# (C) Karandash Type Foundry            (http://www.karandash.eu)
#------------------------------------------------------------
# www.typerig.com

Classes

• typerig.core.objects.collection.CustomList(_abcoll.MutableSequence)
• • PointArray

class PointArray(typerig.core.objects.collection.CustomList)

# - Classes -----------------------------
# -- Point Collections ------------------

Method resolution order:

PointArray

typerig.core.objects.collection.CustomList

abcoll.MutableSequence

_abcoll.Sequence

_abcoll.Sized

_abcoll.Iterable

_abcoll.Container

__builtin_.object

Methods

add(self, other)

# - Internals

delitem(self, i)

div(self, other)

init(self, data, useVoid=False)

mul(self, other)

radd = add(self, other)

rdiv = div(self, other)

repr(self)

rmul = mul(self, other)

rsub = sub(self, other)

sub(self, other)

truediv = div(self, other)

doTransform(self, transform=None)

pop(self, i=-1)

remove(self, item)

Descriptors

angles

bounds

center

diffs

height

tuple

width

x

x_tuple

y

y_tuple

Attributes

abstractmethods = frozenset([])

iadd = None

idiv = None

imul = None

isub = None

Methods from typerig.core.objects.collection.CustomList

cmp(self, other)

contains(self, item)

delslice(self, i, j)

eq(self, other)

ge(self, other)

getitem(self, i)

getslice(self, i, j)

gt(self, other)

le(self, other)

len(self)

lt(self, other)

ne(self, other)

setitem(self, i, item)

setslice(self, i, j, other)

append(self, item)

count(self, item)

extend(self, other)

index(self, item, *args)

insert(self, i, item)

reverse(self)

sort(self, *args, **kwds)

Attributes from typerig.core.objects.collection.CustomList

hash = None

Methods from abcoll.Sequence

__iter_(self)

reversed(self)

Class methods from abcoll.Sized

__subclasshook_(cls, C) from abc.ABCMeta

Descriptors from abcoll.Sized

__dict_

dictionary for instance variables (if defined)

weakref

list of weak references to the object (if defined)

Attributes from abcoll.Sized

__metaclass_ = <class 'abc.ABCMeta'>

Metaclass for defining Abstract Base Classes (ABCs).

Use this metaclass to create an ABC.  An ABC can be subclassed
directly, and then acts as a mix-in class.  You can also register
unrelated concrete classes (even built-in classes) and unrelated
ABCs as 'virtual subclasses' -- these and their descendants will
be considered subclasses of the registering ABC by the built-in
issubclass() function, but the registering ABC won't show up in
their MRO (Method Resolution Order) nor will method
implementations defined by the registering ABC be callable (not
even via super()).