-- |
-- Module:      Data.Vector.Rotcev
-- Copyright:   (c) 2019 Andrew Lelechenko
-- Licence:     BSD3
-- Maintainer:  Andrew Lelechenko <andrew.lelechenko@gmail.com>
--
-- A wrapper for an arbitrary 'V.Vector' with O(1) 'reverse'.
-- Instead of creating a copy, it just flips a flag, which inverts indexing.
-- Imagine it as a vector with a switch between little-endianness and big-endianness.

{-# LANGUAGE BangPatterns          #-}
{-# LANGUAGE FlexibleContexts      #-}
{-# LANGUAGE FlexibleInstances     #-}
{-# LANGUAGE LambdaCase            #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE TypeFamilies          #-}
{-# LANGUAGE UndecidableInstances  #-}

module Data.Vector.Rotcev
  ( Rotcev(..)
  , reverse
  , unRotcev
  , MRotcev(..)
  , mreverse
  ) where

import Prelude hiding (reverse)
import Data.Function
import qualified Data.Vector.Generic as V
import qualified Data.Vector.Generic.Mutable as MV

-- | Wrapper for immutable vectors, equipped with a 'V.Vector' instance.
--
-- >>> Forward  (Data.Vector.fromList [0..100]) Data.Vector.Generic.! 10
-- 10
-- >>> Backward (Data.Vector.fromList [0..100]) Data.Vector.Generic.! 10
-- 90
data Rotcev v a
  = Forward  !(v a)
  -- ^ Behaves as an original vector in respect to 'V.Vector' operations.
  | Backward !(v a)
  -- ^ Behaves as a reversed vector in respect to 'V.Vector' operations.
  deriving (Rotcev v a -> Rotcev v a -> Bool
(Rotcev v a -> Rotcev v a -> Bool)
-> (Rotcev v a -> Rotcev v a -> Bool) -> Eq (Rotcev v a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (v :: * -> *) a.
Eq (v a) =>
Rotcev v a -> Rotcev v a -> Bool
/= :: Rotcev v a -> Rotcev v a -> Bool
$c/= :: forall (v :: * -> *) a.
Eq (v a) =>
Rotcev v a -> Rotcev v a -> Bool
== :: Rotcev v a -> Rotcev v a -> Bool
$c== :: forall (v :: * -> *) a.
Eq (v a) =>
Rotcev v a -> Rotcev v a -> Bool
Eq, Eq (Rotcev v a)
Eq (Rotcev v a)
-> (Rotcev v a -> Rotcev v a -> Ordering)
-> (Rotcev v a -> Rotcev v a -> Bool)
-> (Rotcev v a -> Rotcev v a -> Bool)
-> (Rotcev v a -> Rotcev v a -> Bool)
-> (Rotcev v a -> Rotcev v a -> Bool)
-> (Rotcev v a -> Rotcev v a -> Rotcev v a)
-> (Rotcev v a -> Rotcev v a -> Rotcev v a)
-> Ord (Rotcev v a)
Rotcev v a -> Rotcev v a -> Bool
Rotcev v a -> Rotcev v a -> Ordering
Rotcev v a -> Rotcev v a -> Rotcev v a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall (v :: * -> *) a. Ord (v a) => Eq (Rotcev v a)
forall (v :: * -> *) a.
Ord (v a) =>
Rotcev v a -> Rotcev v a -> Bool
forall (v :: * -> *) a.
Ord (v a) =>
Rotcev v a -> Rotcev v a -> Ordering
forall (v :: * -> *) a.
Ord (v a) =>
Rotcev v a -> Rotcev v a -> Rotcev v a
min :: Rotcev v a -> Rotcev v a -> Rotcev v a
$cmin :: forall (v :: * -> *) a.
Ord (v a) =>
Rotcev v a -> Rotcev v a -> Rotcev v a
max :: Rotcev v a -> Rotcev v a -> Rotcev v a
$cmax :: forall (v :: * -> *) a.
Ord (v a) =>
Rotcev v a -> Rotcev v a -> Rotcev v a
>= :: Rotcev v a -> Rotcev v a -> Bool
$c>= :: forall (v :: * -> *) a.
Ord (v a) =>
Rotcev v a -> Rotcev v a -> Bool
> :: Rotcev v a -> Rotcev v a -> Bool
$c> :: forall (v :: * -> *) a.
Ord (v a) =>
Rotcev v a -> Rotcev v a -> Bool
<= :: Rotcev v a -> Rotcev v a -> Bool
$c<= :: forall (v :: * -> *) a.
Ord (v a) =>
Rotcev v a -> Rotcev v a -> Bool
< :: Rotcev v a -> Rotcev v a -> Bool
$c< :: forall (v :: * -> *) a.
Ord (v a) =>
Rotcev v a -> Rotcev v a -> Bool
compare :: Rotcev v a -> Rotcev v a -> Ordering
$ccompare :: forall (v :: * -> *) a.
Ord (v a) =>
Rotcev v a -> Rotcev v a -> Ordering
$cp1Ord :: forall (v :: * -> *) a. Ord (v a) => Eq (Rotcev v a)
Ord, Int -> Rotcev v a -> ShowS
[Rotcev v a] -> ShowS
Rotcev v a -> String
(Int -> Rotcev v a -> ShowS)
-> (Rotcev v a -> String)
-> ([Rotcev v a] -> ShowS)
-> Show (Rotcev v a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall (v :: * -> *) a. Show (v a) => Int -> Rotcev v a -> ShowS
forall (v :: * -> *) a. Show (v a) => [Rotcev v a] -> ShowS
forall (v :: * -> *) a. Show (v a) => Rotcev v a -> String
showList :: [Rotcev v a] -> ShowS
$cshowList :: forall (v :: * -> *) a. Show (v a) => [Rotcev v a] -> ShowS
show :: Rotcev v a -> String
$cshow :: forall (v :: * -> *) a. Show (v a) => Rotcev v a -> String
showsPrec :: Int -> Rotcev v a -> ShowS
$cshowsPrec :: forall (v :: * -> *) a. Show (v a) => Int -> Rotcev v a -> ShowS
Show)

fromRotcev :: Rotcev v a -> v a
fromRotcev :: Rotcev v a -> v a
fromRotcev = \case
  Forward  v a
v -> v a
v
  Backward v a
v -> v a
v
{-# INLINE fromRotcev #-}

-- | Reverse an immutable vector in O(1) time and space.
--
-- >>> vec = Data.Vector.Generic.fromList [0..100] :: Rotcev Data.Vector.Vector Int
-- >>> reverse vec Data.Vector.Generic.! 10
-- 90
reverse :: Rotcev v a -> Rotcev v a
reverse :: Rotcev v a -> Rotcev v a
reverse = \case
  Forward  v a
v -> v a -> Rotcev v a
forall (v :: * -> *) a. v a -> Rotcev v a
Backward v a
v
  Backward v a
v -> v a -> Rotcev v a
forall (v :: * -> *) a. v a -> Rotcev v a
Forward  v a
v
{-# INLINE reverse #-}

-- | Unwrap 'Rotcev', extracting an underlying vector.
-- This takes O(1) for 'Forward', but full O(n) time for 'Backward' case,
-- so it would rather be avoided in intermediate computations.
-- Instead leverage opportunities, provided by generic 'V.Vector'
-- and 'MV.MVector' instances.
unRotcev :: V.Vector v a => Rotcev v a -> v a
unRotcev :: Rotcev v a -> v a
unRotcev = \case
  Forward v a
v  -> v a
v
  Backward v a
v -> v a -> v a
forall (v :: * -> *) a. Vector v a => v a -> v a
V.reverse v a
v
{-# INLINE unRotcev #-}

-- | Wrapper for mutable vectors, equipped with a 'MV.MVector' instance.
data MRotcev v s a
  = MForward  !(V.Mutable v s a)
  -- ^ Behaves as an original vector in respect to 'MV.MVector' operations.
  | MBackward !(V.Mutable v s a)
  -- ^ Behaves as a reversed vector in respect to 'MV.MVector' operations.

fromMRotcev :: MRotcev v s a -> V.Mutable v s a
fromMRotcev :: MRotcev v s a -> Mutable v s a
fromMRotcev = \case
  MForward  Mutable v s a
v -> Mutable v s a
v
  MBackward Mutable v s a
v -> Mutable v s a
v
{-# INLINE fromMRotcev #-}

-- | Reverse a mutable vector in O(1) time and space.
mreverse :: MRotcev v s a -> MRotcev v s a
mreverse :: MRotcev v s a -> MRotcev v s a
mreverse = \case
  MForward  Mutable v s a
v -> Mutable v s a -> MRotcev v s a
forall (v :: * -> *) s a. Mutable v s a -> MRotcev v s a
MBackward Mutable v s a
v
  MBackward Mutable v s a
v -> Mutable v s a -> MRotcev v s a
forall (v :: * -> *) s a. Mutable v s a -> MRotcev v s a
MForward  Mutable v s a
v
{-# INLINE mreverse #-}

type instance V.Mutable (Rotcev v) = MRotcev v

instance MV.MVector (V.Mutable v) a => MV.MVector (MRotcev v) a where
  basicLength :: MRotcev v s a -> Int
basicLength = Mutable v s a -> Int
forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int
MV.basicLength (Mutable v s a -> Int)
-> (MRotcev v s a -> Mutable v s a) -> MRotcev v s a -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MRotcev v s a -> Mutable v s a
forall (v :: * -> *) s a. MRotcev v s a -> Mutable v s a
fromMRotcev
  basicUnsafeSlice :: Int -> Int -> MRotcev v s a -> MRotcev v s a
basicUnsafeSlice Int
off Int
len = \case
    MForward  Mutable v s a
v -> Mutable v s a -> MRotcev v s a
forall (v :: * -> *) s a. Mutable v s a -> MRotcev v s a
MForward  (Mutable v s a -> MRotcev v s a) -> Mutable v s a -> MRotcev v s a
forall a b. (a -> b) -> a -> b
$ Int -> Int -> Mutable v s a -> Mutable v s a
forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> Int -> v s a -> v s a
MV.basicUnsafeSlice Int
off Int
len Mutable v s a
v
    MBackward Mutable v s a
v -> Mutable v s a -> MRotcev v s a
forall (v :: * -> *) s a. Mutable v s a -> MRotcev v s a
MBackward (Mutable v s a -> MRotcev v s a) -> Mutable v s a -> MRotcev v s a
forall a b. (a -> b) -> a -> b
$ Int -> Int -> Mutable v s a -> Mutable v s a
forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> Int -> v s a -> v s a
MV.basicUnsafeSlice (Mutable v s a -> Int
forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int
MV.basicLength Mutable v s a
v Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
off Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
len) Int
len Mutable v s a
v
  basicOverlaps :: MRotcev v s a -> MRotcev v s a -> Bool
basicOverlaps = Mutable v s a -> Mutable v s a -> Bool
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> Bool
MV.basicOverlaps (Mutable v s a -> Mutable v s a -> Bool)
-> (MRotcev v s a -> Mutable v s a)
-> MRotcev v s a
-> MRotcev v s a
-> Bool
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` MRotcev v s a -> Mutable v s a
forall (v :: * -> *) s a. MRotcev v s a -> Mutable v s a
fromMRotcev
  basicUnsafeNew :: Int -> m (MRotcev v (PrimState m) a)
basicUnsafeNew = (Mutable v (PrimState m) a -> MRotcev v (PrimState m) a)
-> m (Mutable v (PrimState m) a) -> m (MRotcev v (PrimState m) a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Mutable v (PrimState m) a -> MRotcev v (PrimState m) a
forall (v :: * -> *) s a. Mutable v s a -> MRotcev v s a
MForward (m (Mutable v (PrimState m) a) -> m (MRotcev v (PrimState m) a))
-> (Int -> m (Mutable v (PrimState m) a))
-> Int
-> m (MRotcev v (PrimState m) a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> m (Mutable v (PrimState m) a)
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
Int -> m (v (PrimState m) a)
MV.basicUnsafeNew
  basicInitialize :: MRotcev v (PrimState m) a -> m ()
basicInitialize = Mutable v (PrimState m) a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> m ()
MV.basicInitialize (Mutable v (PrimState m) a -> m ())
-> (MRotcev v (PrimState m) a -> Mutable v (PrimState m) a)
-> MRotcev v (PrimState m) a
-> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MRotcev v (PrimState m) a -> Mutable v (PrimState m) a
forall (v :: * -> *) s a. MRotcev v s a -> Mutable v s a
fromMRotcev
  basicUnsafeReplicate :: Int -> a -> m (MRotcev v (PrimState m) a)
basicUnsafeReplicate = ((Mutable v (PrimState m) a -> MRotcev v (PrimState m) a)
-> m (Mutable v (PrimState m) a) -> m (MRotcev v (PrimState m) a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Mutable v (PrimState m) a -> MRotcev v (PrimState m) a
forall (v :: * -> *) s a. Mutable v s a -> MRotcev v s a
MForward (m (Mutable v (PrimState m) a) -> m (MRotcev v (PrimState m) a))
-> (a -> m (Mutable v (PrimState m) a))
-> a
-> m (MRotcev v (PrimState m) a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((a -> m (Mutable v (PrimState m) a))
 -> a -> m (MRotcev v (PrimState m) a))
-> (Int -> a -> m (Mutable v (PrimState m) a))
-> Int
-> a
-> m (MRotcev v (PrimState m) a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> a -> m (Mutable v (PrimState m) a)
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
Int -> a -> m (v (PrimState m) a)
MV.basicUnsafeReplicate
  basicUnsafeRead :: MRotcev v (PrimState m) a -> Int -> m a
basicUnsafeRead = \case
    MForward  Mutable v (PrimState m) a
v -> Mutable v (PrimState m) a -> Int -> m a
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> m a
MV.basicUnsafeRead Mutable v (PrimState m) a
v
    MBackward Mutable v (PrimState m) a
v -> Mutable v (PrimState m) a -> Int -> m a
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> m a
MV.basicUnsafeRead Mutable v (PrimState m) a
v (Int -> m a) -> (Int -> Int) -> Int -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Mutable v (PrimState m) a -> Int
forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int
MV.basicLength Mutable v (PrimState m) a
v Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) Int -> Int -> Int
forall a. Num a => a -> a -> a
-)
  basicUnsafeWrite :: MRotcev v (PrimState m) a -> Int -> a -> m ()
basicUnsafeWrite = \case
    MForward  Mutable v (PrimState m) a
v -> Mutable v (PrimState m) a -> Int -> a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> a -> m ()
MV.basicUnsafeWrite Mutable v (PrimState m) a
v
    MBackward Mutable v (PrimState m) a
v -> Mutable v (PrimState m) a -> Int -> a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> a -> m ()
MV.basicUnsafeWrite Mutable v (PrimState m) a
v (Int -> a -> m ()) -> (Int -> Int) -> Int -> a -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Mutable v (PrimState m) a -> Int
forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int
MV.basicLength Mutable v (PrimState m) a
v Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) Int -> Int -> Int
forall a. Num a => a -> a -> a
-)
  basicClear :: MRotcev v (PrimState m) a -> m ()
basicClear = Mutable v (PrimState m) a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> m ()
MV.basicClear (Mutable v (PrimState m) a -> m ())
-> (MRotcev v (PrimState m) a -> Mutable v (PrimState m) a)
-> MRotcev v (PrimState m) a
-> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MRotcev v (PrimState m) a -> Mutable v (PrimState m) a
forall (v :: * -> *) s a. MRotcev v s a -> Mutable v s a
fromMRotcev
  basicSet :: MRotcev v (PrimState m) a -> a -> m ()
basicSet = Mutable v (PrimState m) a -> a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> a -> m ()
MV.basicSet (Mutable v (PrimState m) a -> a -> m ())
-> (MRotcev v (PrimState m) a -> Mutable v (PrimState m) a)
-> MRotcev v (PrimState m) a
-> a
-> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MRotcev v (PrimState m) a -> Mutable v (PrimState m) a
forall (v :: * -> *) s a. MRotcev v s a -> Mutable v s a
fromMRotcev

  basicUnsafeCopy :: MRotcev v (PrimState m) a -> MRotcev v (PrimState m) a -> m ()
basicUnsafeCopy !MRotcev v (PrimState m) a
dst' !MRotcev v (PrimState m) a
src' = case MRotcev v (PrimState m) a
dst' of
    MForward{} -> case MRotcev v (PrimState m) a
src' of
      MForward{}  -> Mutable v (PrimState m) a -> Mutable v (PrimState m) a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> v (PrimState m) a -> m ()
MV.basicUnsafeCopy Mutable v (PrimState m) a
dst Mutable v (PrimState m) a
src
      MBackward{} -> Int -> m ()
do_copy Int
0
    MBackward{} -> case MRotcev v (PrimState m) a
src' of
      MForward{}  -> Int -> m ()
do_copy Int
0
      MBackward{} -> Mutable v (PrimState m) a -> Mutable v (PrimState m) a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> v (PrimState m) a -> m ()
MV.basicUnsafeCopy Mutable v (PrimState m) a
dst Mutable v (PrimState m) a
src
    where
      dst :: Mutable v (PrimState m) a
dst = MRotcev v (PrimState m) a -> Mutable v (PrimState m) a
forall (v :: * -> *) s a. MRotcev v s a -> Mutable v s a
fromMRotcev MRotcev v (PrimState m) a
dst'
      src :: Mutable v (PrimState m) a
src = MRotcev v (PrimState m) a -> Mutable v (PrimState m) a
forall (v :: * -> *) s a. MRotcev v s a -> Mutable v s a
fromMRotcev MRotcev v (PrimState m) a
src'
      !n :: Int
n = Mutable v (PrimState m) a -> Int
forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int
MV.basicLength Mutable v (PrimState m) a
src
      do_copy :: Int -> m ()
do_copy Int
i
        | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
n = do
          a
x <- Mutable v (PrimState m) a -> Int -> m a
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> m a
MV.basicUnsafeRead Mutable v (PrimState m) a
src Int
i
          Mutable v (PrimState m) a -> Int -> a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> a -> m ()
MV.basicUnsafeWrite Mutable v (PrimState m) a
dst (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1 Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
i) a
x
          Int -> m ()
do_copy (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
        | Bool
otherwise = () -> m ()
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()

  basicUnsafeMove :: MRotcev v (PrimState m) a -> MRotcev v (PrimState m) a -> m ()
basicUnsafeMove !MRotcev v (PrimState m) a
dst !MRotcev v (PrimState m) a
src
    | MRotcev v (PrimState m) a -> MRotcev v (PrimState m) a -> Bool
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> Bool
MV.basicOverlaps MRotcev v (PrimState m) a
dst MRotcev v (PrimState m) a
src = do
      Mutable v (PrimState m) a
srcCopy' <- Int -> m (Mutable v (PrimState m) a)
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
Int -> m (v (PrimState m) a)
MV.basicUnsafeNew (MRotcev v (PrimState m) a -> Int
forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int
MV.basicLength MRotcev v (PrimState m) a
src)
      let srcCopy :: MRotcev v (PrimState m) a
srcCopy = case MRotcev v (PrimState m) a
dst of
            MForward{}  -> Mutable v (PrimState m) a -> MRotcev v (PrimState m) a
forall (v :: * -> *) s a. Mutable v s a -> MRotcev v s a
MForward Mutable v (PrimState m) a
srcCopy'
            MBackward{} -> case MRotcev v (PrimState m) a
src of
              MForward{}  -> Mutable v (PrimState m) a -> MRotcev v (PrimState m) a
forall (v :: * -> *) s a. Mutable v s a -> MRotcev v s a
MForward Mutable v (PrimState m) a
srcCopy'
              MBackward{} -> Mutable v (PrimState m) a -> MRotcev v (PrimState m) a
forall (v :: * -> *) s a. Mutable v s a -> MRotcev v s a
MBackward Mutable v (PrimState m) a
srcCopy'
      MRotcev v (PrimState m) a -> MRotcev v (PrimState m) a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> v (PrimState m) a -> m ()
MV.basicUnsafeCopy MRotcev v (PrimState m) a
srcCopy MRotcev v (PrimState m) a
src
      MRotcev v (PrimState m) a -> MRotcev v (PrimState m) a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> v (PrimState m) a -> m ()
MV.basicUnsafeCopy MRotcev v (PrimState m) a
dst MRotcev v (PrimState m) a
srcCopy
    | Bool
otherwise = MRotcev v (PrimState m) a -> MRotcev v (PrimState m) a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> v (PrimState m) a -> m ()
MV.basicUnsafeCopy MRotcev v (PrimState m) a
dst MRotcev v (PrimState m) a
src

  basicUnsafeGrow :: MRotcev v (PrimState m) a -> Int -> m (MRotcev v (PrimState m) a)
basicUnsafeGrow (MForward Mutable v (PrimState m) a
v) Int
by = do
    let n :: Int
n = Mutable v (PrimState m) a -> Int
forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int
MV.basicLength Mutable v (PrimState m) a
v
    Mutable v (PrimState m) a
v' <- Int -> m (Mutable v (PrimState m) a)
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
Int -> m (v (PrimState m) a)
MV.basicUnsafeNew (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
by)
    Mutable v (PrimState m) a -> Mutable v (PrimState m) a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> v (PrimState m) a -> m ()
MV.basicUnsafeCopy (Int
-> Int -> Mutable v (PrimState m) a -> Mutable v (PrimState m) a
forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> Int -> v s a -> v s a
MV.basicUnsafeSlice Int
0 Int
n Mutable v (PrimState m) a
v') Mutable v (PrimState m) a
v
    MRotcev v (PrimState m) a -> m (MRotcev v (PrimState m) a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (MRotcev v (PrimState m) a -> m (MRotcev v (PrimState m) a))
-> MRotcev v (PrimState m) a -> m (MRotcev v (PrimState m) a)
forall a b. (a -> b) -> a -> b
$ Mutable v (PrimState m) a -> MRotcev v (PrimState m) a
forall (v :: * -> *) s a. Mutable v s a -> MRotcev v s a
MForward Mutable v (PrimState m) a
v'
  basicUnsafeGrow (MBackward Mutable v (PrimState m) a
v) Int
by = do
    let n :: Int
n = Mutable v (PrimState m) a -> Int
forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int
MV.basicLength Mutable v (PrimState m) a
v
    Mutable v (PrimState m) a
v' <- Int -> m (Mutable v (PrimState m) a)
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
Int -> m (v (PrimState m) a)
MV.basicUnsafeNew (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
by)
    Mutable v (PrimState m) a -> Mutable v (PrimState m) a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> v (PrimState m) a -> m ()
MV.basicUnsafeCopy (Int
-> Int -> Mutable v (PrimState m) a -> Mutable v (PrimState m) a
forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> Int -> v s a -> v s a
MV.basicUnsafeSlice Int
by Int
n Mutable v (PrimState m) a
v') Mutable v (PrimState m) a
v
    MRotcev v (PrimState m) a -> m (MRotcev v (PrimState m) a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (MRotcev v (PrimState m) a -> m (MRotcev v (PrimState m) a))
-> MRotcev v (PrimState m) a -> m (MRotcev v (PrimState m) a)
forall a b. (a -> b) -> a -> b
$ Mutable v (PrimState m) a -> MRotcev v (PrimState m) a
forall (v :: * -> *) s a. Mutable v s a -> MRotcev v s a
MBackward Mutable v (PrimState m) a
v'

  {-# INLINE basicLength           #-}
  {-# INLINE basicUnsafeSlice      #-}
  {-# INLINE basicOverlaps         #-}
  {-# INLINE basicUnsafeNew        #-}
  {-# INLINE basicInitialize       #-}
  {-# INLINE basicUnsafeReplicate  #-}
  {-# INLINE basicUnsafeRead       #-}
  {-# INLINE basicUnsafeWrite      #-}
  {-# INLINE basicUnsafeCopy       #-}
  {-# INLINE basicUnsafeMove       #-}
  {-# INLINE basicUnsafeGrow       #-}

instance V.Vector v a => V.Vector (Rotcev v) a where
  basicUnsafeFreeze :: Mutable (Rotcev v) (PrimState m) a -> m (Rotcev v a)
basicUnsafeFreeze = \case
    MForward  v -> v a -> Rotcev v a
forall (v :: * -> *) a. v a -> Rotcev v a
Forward  (v a -> Rotcev v a) -> m (v a) -> m (Rotcev v a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mutable v (PrimState m) a -> m (v a)
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, PrimMonad m) =>
Mutable v (PrimState m) a -> m (v a)
V.basicUnsafeFreeze Mutable v (PrimState m) a
v
    MBackward v -> v a -> Rotcev v a
forall (v :: * -> *) a. v a -> Rotcev v a
Backward (v a -> Rotcev v a) -> m (v a) -> m (Rotcev v a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mutable v (PrimState m) a -> m (v a)
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, PrimMonad m) =>
Mutable v (PrimState m) a -> m (v a)
V.basicUnsafeFreeze Mutable v (PrimState m) a
v
  basicUnsafeThaw :: Rotcev v a -> m (Mutable (Rotcev v) (PrimState m) a)
basicUnsafeThaw = \case
    Forward  v a
v -> Mutable v (PrimState m) a -> MRotcev v (PrimState m) a
forall (v :: * -> *) s a. Mutable v s a -> MRotcev v s a
MForward  (Mutable v (PrimState m) a -> MRotcev v (PrimState m) a)
-> m (Mutable v (PrimState m) a) -> m (MRotcev v (PrimState m) a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> v a -> m (Mutable v (PrimState m) a)
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, PrimMonad m) =>
v a -> m (Mutable v (PrimState m) a)
V.basicUnsafeThaw v a
v
    Backward v a
v -> Mutable v (PrimState m) a -> MRotcev v (PrimState m) a
forall (v :: * -> *) s a. Mutable v s a -> MRotcev v s a
MBackward (Mutable v (PrimState m) a -> MRotcev v (PrimState m) a)
-> m (Mutable v (PrimState m) a) -> m (MRotcev v (PrimState m) a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> v a -> m (Mutable v (PrimState m) a)
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, PrimMonad m) =>
v a -> m (Mutable v (PrimState m) a)
V.basicUnsafeThaw v a
v
  basicLength :: Rotcev v a -> Int
basicLength = v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
V.basicLength (v a -> Int) -> (Rotcev v a -> v a) -> Rotcev v a -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rotcev v a -> v a
forall (v :: * -> *) a. Rotcev v a -> v a
fromRotcev
  basicUnsafeSlice :: Int -> Int -> Rotcev v a -> Rotcev v a
basicUnsafeSlice Int
off Int
len = \case
    Forward  v a
v -> v a -> Rotcev v a
forall (v :: * -> *) a. v a -> Rotcev v a
Forward  (v a -> Rotcev v a) -> v a -> Rotcev v a
forall a b. (a -> b) -> a -> b
$ Int -> Int -> v a -> v a
forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
V.basicUnsafeSlice Int
off Int
len v a
v
    Backward v a
v -> v a -> Rotcev v a
forall (v :: * -> *) a. v a -> Rotcev v a
Backward (v a -> Rotcev v a) -> v a -> Rotcev v a
forall a b. (a -> b) -> a -> b
$ Int -> Int -> v a -> v a
forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
V.basicUnsafeSlice (v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
V.basicLength v a
v Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
off Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
len) Int
len v a
v
  basicUnsafeIndexM :: Rotcev v a -> Int -> m a
basicUnsafeIndexM = \case
    Forward  v a
v -> v a -> Int -> m a
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> Int -> m a
V.basicUnsafeIndexM v a
v
    Backward v a
v -> v a -> Int -> m a
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> Int -> m a
V.basicUnsafeIndexM v a
v (Int -> m a) -> (Int -> Int) -> Int -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
V.basicLength v a
v Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) Int -> Int -> Int
forall a. Num a => a -> a -> a
-)

  basicUnsafeCopy :: Mutable (Rotcev v) (PrimState m) a -> Rotcev v a -> m ()
basicUnsafeCopy !Mutable (Rotcev v) (PrimState m) a
dst' !Rotcev v a
src' = case Mutable (Rotcev v) (PrimState m) a
dst' of
    MForward{} -> case Rotcev v a
src' of
      Forward{}  -> Mutable v (PrimState m) a -> v a -> m ()
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, PrimMonad m) =>
Mutable v (PrimState m) a -> v a -> m ()
V.basicUnsafeCopy Mutable v (PrimState m) a
dst v a
src
      Backward{} -> Int -> m ()
do_copy Int
0
    MBackward{} -> case Rotcev v a
src' of
      Forward{}  -> Int -> m ()
do_copy Int
0
      Backward{} -> Mutable v (PrimState m) a -> v a -> m ()
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, PrimMonad m) =>
Mutable v (PrimState m) a -> v a -> m ()
V.basicUnsafeCopy Mutable v (PrimState m) a
dst v a
src
    where
      dst :: Mutable v (PrimState m) a
dst = MRotcev v (PrimState m) a -> Mutable v (PrimState m) a
forall (v :: * -> *) s a. MRotcev v s a -> Mutable v s a
fromMRotcev Mutable (Rotcev v) (PrimState m) a
MRotcev v (PrimState m) a
dst'
      src :: v a
src = Rotcev v a -> v a
forall (v :: * -> *) a. Rotcev v a -> v a
fromRotcev  Rotcev v a
src'
      !n :: Int
n = v a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
V.basicLength v a
src
      do_copy :: Int -> m ()
do_copy Int
i
        | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
n = do
          a
x <- v a -> Int -> m a
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> Int -> m a
V.basicUnsafeIndexM v a
src Int
i
          Mutable v (PrimState m) a -> Int -> a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> a -> m ()
MV.basicUnsafeWrite Mutable v (PrimState m) a
dst (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1 Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
i) a
x
          Int -> m ()
do_copy (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
        | Bool
otherwise = () -> m ()
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()

  {-# INLINE basicUnsafeFreeze #-}
  {-# INLINE basicUnsafeThaw   #-}
  {-# INLINE basicLength       #-}
  {-# INLINE basicUnsafeSlice  #-}
  {-# INLINE basicUnsafeIndexM #-}
  {-# INLINE basicUnsafeCopy   #-}