Skip to content

# `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

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