Game.TCOD.List

Documentation

newtype TCODList a

This is a fast, lightweight and generic container, that provides array, list and stack paradigms.

Constructors

TCODList

Fields

• unTCODList :: Ptr ()

Instances

Eq (TCODList a)

Methods

(==) :: TCODList a -> TCODList a -> Bool

(/=) :: TCODList a -> TCODList a -> Bool

Ord (TCODList a)

Methods

compare :: TCODList a -> TCODList a -> Ordering

(<) :: TCODList a -> TCODList a -> Bool

(<=) :: TCODList a -> TCODList a -> Bool

(>) :: TCODList a -> TCODList a -> Bool

(>=) :: TCODList a -> TCODList a -> Bool

max :: TCODList a -> TCODList a -> TCODList a

min :: TCODList a -> TCODList a -> TCODList a

Show (TCODList a)

Methods

showsPrec :: Int -> TCODList a -> ShowS

show :: TCODList a -> String

showList :: [TCODList a] -> ShowS

Generic (TCODList a)

Associated Types

type Rep (TCODList a) :: * -> *

Methods

from :: TCODList a -> Rep (TCODList a) x

to :: Rep (TCODList a) x -> TCODList a

type Rep (TCODList a)

type Rep (TCODList a) = D1 (MetaData "TCODList" "Game.TCOD.List" "tcod-haskell-0.1.0.0-9JdFGODCf32GFoGmrQ4wdi" True) (C1 (MetaCons "TCODList" PrefixI True) (S1 (MetaSel (Just Symbol "unTCODList") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Ptr ()))))

listNew :: IO (TCODList a)

Creating a list

listAllocate

Arguments

:: Int

Number of elements

-> IO (TCODList a)

You can also create an empty list and pre-allocate memory for elements. Use this if you know the list size and want the memory to fit it perfectly.

listDuplicated :: TCODList a -> IO (TCODList a)

You can create a list by duplicating an existing list.

listDelete :: TCODList a -> IO ()

You can delete a list, freeing any allocated resources. Note that deleting the list does not delete it's elements. You have to use clearAndDelete before deleting the list if you want to destroy the elements too.

listPush :: Storable a => TCODList a -> a -> IO ()

You can push an element on the stack (append it to the end of the list)

listPushPtr :: TCODList a -> Ptr a -> IO ()

You can push an element on the stack (append it to the end of the list)

listPop :: Storable a => TCODList a -> IO (Maybe a)

You can pop an element from the stack (remove the last element of the list).

listPopPtr :: TCODList a -> IO (Ptr a)

You can pop an element from the stack (remove the last element of the list).

listPeek :: Storable a => TCODList a -> IO (Maybe a)

You can read the last element of the stack without removing it :

listPeekPtr :: TCODList a -> IO (Ptr a)

You can read the last element of the stack without removing it :

listAddAll :: TCODList a -> TCODList a -> IO ()

You can concatenate two lists. Every element of l2 will be added to current list

listGet :: Storable a => TCODList a -> Int -> IO (Maybe a)

You can retrieve a value with get.

listGetPtr :: TCODList a -> Int -> IO (Ptr a)

You can retrieve a value with get.

listSet :: Storable a => TCODList a -> a -> Int -> IO ()

You can assign a value with set. If needed, the array will allocate new elements up to idx.

listSetPtr :: TCODList a -> Ptr a -> Int -> IO ()

You can assign a value with set. If needed, the array will allocate new elements up to idx.

listBeginPtr :: TCODList a -> IO (Ptr (Ptr a))

You can iterate through the elements of the list using an iterator. begin() returns the address of the first element of the list. You go to the next element using the increment operator ++. When the iterator's value is equal to end(), you've gone through all the elements.

Warning ! You cannot insert elements in the list while iterating through it. Inserting elements can result in reallocation of the list and your iterator will not longer be valid.

listEndPtr :: TCODList a -> IO (Ptr (Ptr a))

You can iterate through the elements of the list using an iterator. begin() returns the address of the first element of the list. You go to the next element using the increment operator ++. When the iterator's value is equal to end(), you've gone through all the elements.

Warning ! You cannot insert elements in the list while iterating through it. Inserting elements can result in reallocation of the list and your iterator will not longer be valid.

listReverse :: TCODList a -> IO ()

This function reverses the order of the elements in the list.

listRemoveIterator :: TCODList a -> Ptr (Ptr a) -> IO (Ptr (Ptr a))

You can remove an element from the list while iterating. The element at the iterator position will be removed. The function returns the new iterator. The _fast versions replace the element to remove with the last element of the list. They're faster, but do not preserve the list order.

listRemoveIteratorFast :: TCODList a -> Ptr (Ptr a) -> IO (Ptr (Ptr a))

You can remove an element from the list while iterating. The element at the iterator position will be removed. The function returns the new iterator. The _fast versions replace the element to remove with the last element of the list. They're faster, but do not preserve the list order.

listRemovePtr :: TCODList a -> Ptr a -> IO ()

Removing an element from the list

listRemove :: Storable a => TCODList a -> a -> IO ()

Removing an element from the list

listRemoveFastPtr :: TCODList a -> Ptr a -> IO ()

The _fast versions replace the element to remove with the last element of the list. They're faster, but do not preserve the list order.

listRemoveFast :: Storable a => TCODList a -> a -> IO ()

The _fast versions replace the element to remove with the last element of the list. They're faster, but do not preserve the list order.

listContainsPtr :: TCODList a -> Ptr a -> IO Bool

Checking if an element is in the list

listContains :: Storable a => TCODList a -> a -> IO Bool

Checking if an element is in the list

listClear :: TCODList a -> IO ()

Emptying a list

listClearAndDelete :: TCODList a -> IO ()

For lists containing pointers, you can clear the list and delete (or free for C) the elements :

listSize :: TCODList a -> IO Int

Getting the list size

listInsertBeforePtr :: TCODList a -> Ptr a -> Int -> IO (Ptr (Ptr a))

Insert an element in the list

listInsertBefore :: Storable a => TCODList a -> a -> Int -> IO (Ptr (Ptr a))

Insert an element in the list

listIsEmpty :: TCODList a -> IO Bool

Checking if a list is empty

Haskell conversion

listToList :: forall a. Storable a => TCODList a -> IO [a]

Load to Haskell list O(N)

listFromList :: forall a f. (Foldable f, Storable a) => f a -> IO (TCODList a)

Unload Haskell list to TCOD container O(N)

listToVectorUnsafe :: forall a. Storable a => TCODList a -> IO (Vector a)

Convert TCOD list to Haskell storable vector. O(1)

Note: The vector reuses memory of the list and valid until the TCOD list is not deleted or reallocated (due mutation).

listToVector :: forall a. Storable a => TCODList a -> IO (Vector a)

Convert TCOD list to Haskell storable vector. O(N)

Note: The vector content is copied into haskell heap.