typerig.core.objects.array

typerig.core.objects.array (version 0.26.5)

# 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

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

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

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()).