Trait opencv::core::VectorTrait

pub trait VectorTrait<'i>: Sized {
    type Arg;
    fn with_capacity(capacity: size_t) -> Self;
    fn push(&mut self, val: Self::Arg);
    fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>;
    fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>;
    unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg);

    fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self { ... }
}

Common interface for all C++ vector types generated by the crate

You'll need to import this trait to use any of the C++ vector wrappers, usually imported as part of the prelude.

Associated Types

type Arg

Loading content...

Required methods

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Self::Arg)

Add new element

fn insert(&mut self, index: size_t, val: Self::Arg) -> Result<()>

Insert a new element at the specified index

fn set(&mut self, index: size_t, val: Self::Arg) -> Result<()>

Set element at the specified index

unsafe fn set_unchecked(&mut self, index: size_t, val: Self::Arg)

Same as set() but without bounds checking

Loading content...

Provided methods

fn from_iter(s: impl IntoIterator<Item = Self::Arg>) -> Self

Create a Vector from iterator

Loading content...

Implementors

impl<'i> VectorTrait<'i> for Vector<Target>

type Arg = Target

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Target)

fn insert(&mut self, index: size_t, val: Target) -> Result<()>

fn set(&mut self, index: size_t, val: Target) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Target)

impl<'i> VectorTrait<'i> for Vector<FlannIndexType>

type Arg = FlannIndexType

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: FlannIndexType)

fn insert(&mut self, index: size_t, val: FlannIndexType) -> Result<()>

fn set(&mut self, index: size_t, val: FlannIndexType) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: FlannIndexType)

impl<'i> VectorTrait<'i> for Vector<VideoCaptureAPIs>

type Arg = VideoCaptureAPIs

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: VideoCaptureAPIs)

fn insert(&mut self, index: size_t, val: VideoCaptureAPIs) -> Result<()>

fn set(&mut self, index: size_t, val: VideoCaptureAPIs) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: VideoCaptureAPIs)

impl<'i> VectorTrait<'i> for Vector<bool>

type Arg = bool

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: bool)

fn insert(&mut self, index: size_t, val: bool) -> Result<()>

fn set(&mut self, index: size_t, val: bool) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: bool)

impl<'i> VectorTrait<'i> for Vector<f32>

type Arg = f32

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: f32)

fn insert(&mut self, index: size_t, val: f32) -> Result<()>

fn set(&mut self, index: size_t, val: f32) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: f32)

impl<'i> VectorTrait<'i> for Vector<f64>

type Arg = f64

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: f64)

fn insert(&mut self, index: size_t, val: f64) -> Result<()>

fn set(&mut self, index: size_t, val: f64) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: f64)

impl<'i> VectorTrait<'i> for Vector<i32>

type Arg = i32

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: i32)

fn insert(&mut self, index: size_t, val: i32) -> Result<()>

fn set(&mut self, index: size_t, val: i32) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: i32)

impl<'i> VectorTrait<'i> for Vector<i8>

type Arg = i8

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: i8)

fn insert(&mut self, index: size_t, val: i8) -> Result<()>

fn set(&mut self, index: size_t, val: i8) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: i8)

impl<'i> VectorTrait<'i> for Vector<u8>

type Arg = u8

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: u8)

fn insert(&mut self, index: size_t, val: u8) -> Result<()>

fn set(&mut self, index: size_t, val: u8) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: u8)

impl<'i> VectorTrait<'i> for Vector<DMatch>

type Arg = DMatch

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: DMatch)

fn insert(&mut self, index: size_t, val: DMatch) -> Result<()>

fn set(&mut self, index: size_t, val: DMatch) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: DMatch)

impl<'i> VectorTrait<'i> for Vector<KeyPoint>

type Arg = KeyPoint

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: KeyPoint)

fn insert(&mut self, index: size_t, val: KeyPoint) -> Result<()>

fn set(&mut self, index: size_t, val: KeyPoint) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: KeyPoint)

impl<'i> VectorTrait<'i> for Vector<Mat>

type Arg = Mat

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Mat)

fn insert(&mut self, index: size_t, val: Mat) -> Result<()>

fn set(&mut self, index: size_t, val: Mat) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Mat)

impl<'i> VectorTrait<'i> for Vector<PlatformInfo>

type Arg = PlatformInfo

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: PlatformInfo)

fn insert(&mut self, index: size_t, val: PlatformInfo) -> Result<()>

fn set(&mut self, index: size_t, val: PlatformInfo) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: PlatformInfo)

impl<'i> VectorTrait<'i> for Vector<Ptr<BackendNode>>

type Arg = Ptr<BackendNode>

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Ptr<BackendNode>)

fn insert(&mut self, index: size_t, val: Ptr<BackendNode>) -> Result<()>

fn set(&mut self, index: size_t, val: Ptr<BackendNode>) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Ptr<BackendNode>)

impl<'i> VectorTrait<'i> for Vector<Ptr<Layer>>

type Arg = Ptr<Layer>

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Ptr<Layer>)

fn insert(&mut self, index: size_t, val: Ptr<Layer>) -> Result<()>

fn set(&mut self, index: size_t, val: Ptr<Layer>) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Ptr<Layer>)

impl<'i> VectorTrait<'i> for Vector<Ptr<dyn BackendWrapper>>

type Arg = Ptr<dyn BackendWrapper>

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Ptr<dyn BackendWrapper>)

fn insert(&mut self, index: size_t, val: Ptr<dyn BackendWrapper>) -> Result<()>

fn set(&mut self, index: size_t, val: Ptr<dyn BackendWrapper>) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Ptr<dyn BackendWrapper>)

impl<'i> VectorTrait<'i> for Vector<Range>

type Arg = Range

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Range)

fn insert(&mut self, index: size_t, val: Range) -> Result<()>

fn set(&mut self, index: size_t, val: Range) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Range)

impl<'i> VectorTrait<'i> for Vector<RotatedRect>

type Arg = RotatedRect

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: RotatedRect)

fn insert(&mut self, index: size_t, val: RotatedRect) -> Result<()>

fn set(&mut self, index: size_t, val: RotatedRect) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: RotatedRect)

impl<'i> VectorTrait<'i> for Vector<UMat>

type Arg = UMat

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: UMat)

fn insert(&mut self, index: size_t, val: UMat) -> Result<()>

fn set(&mut self, index: size_t, val: UMat) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: UMat)

impl<'i> VectorTrait<'i> for Vector<Vector<f64>>

type Arg = Vector<f64>

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Vector<f64>)

fn insert(&mut self, index: size_t, val: Vector<f64>) -> Result<()>

fn set(&mut self, index: size_t, val: Vector<f64>) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<f64>)

impl<'i> VectorTrait<'i> for Vector<Vector<i32>>

type Arg = Vector<i32>

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Vector<i32>)

fn insert(&mut self, index: size_t, val: Vector<i32>) -> Result<()>

fn set(&mut self, index: size_t, val: Vector<i32>) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<i32>)

impl<'i> VectorTrait<'i> for Vector<Vector<i8>>

type Arg = Vector<i8>

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Vector<i8>)

fn insert(&mut self, index: size_t, val: Vector<i8>) -> Result<()>

fn set(&mut self, index: size_t, val: Vector<i8>) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<i8>)

impl<'i> VectorTrait<'i> for Vector<Vector<u8>>

type Arg = Vector<u8>

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Vector<u8>)

fn insert(&mut self, index: size_t, val: Vector<u8>) -> Result<()>

fn set(&mut self, index: size_t, val: Vector<u8>) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<u8>)

impl<'i> VectorTrait<'i> for Vector<Vector<DMatch>>

type Arg = Vector<DMatch>

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Vector<DMatch>)

fn insert(&mut self, index: size_t, val: Vector<DMatch>) -> Result<()>

fn set(&mut self, index: size_t, val: Vector<DMatch>) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<DMatch>)

impl<'i> VectorTrait<'i> for Vector<Vector<KeyPoint>>

type Arg = Vector<KeyPoint>

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Vector<KeyPoint>)

fn insert(&mut self, index: size_t, val: Vector<KeyPoint>) -> Result<()>

fn set(&mut self, index: size_t, val: Vector<KeyPoint>) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<KeyPoint>)

impl<'i> VectorTrait<'i> for Vector<Vector<Mat>>

type Arg = Vector<Mat>

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Vector<Mat>)

fn insert(&mut self, index: size_t, val: Vector<Mat>) -> Result<()>

fn set(&mut self, index: size_t, val: Vector<Mat>) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<Mat>)

impl<'i> VectorTrait<'i> for Vector<Vector<Range>>

type Arg = Vector<Range>

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Vector<Range>)

fn insert(&mut self, index: size_t, val: Vector<Range>) -> Result<()>

fn set(&mut self, index: size_t, val: Vector<Range>) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<Range>)

impl<'i> VectorTrait<'i> for Vector<Vector<KeyLine>>

type Arg = Vector<KeyLine>

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Vector<KeyLine>)

fn insert(&mut self, index: size_t, val: Vector<KeyLine>) -> Result<()>

fn set(&mut self, index: size_t, val: Vector<KeyLine>) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<KeyLine>)

impl<'i> VectorTrait<'i> for Vector<Vector<ERStat>>

type Arg = Vector<ERStat>

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Vector<ERStat>)

fn insert(&mut self, index: size_t, val: Vector<ERStat>) -> Result<()>

fn set(&mut self, index: size_t, val: Vector<ERStat>) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<ERStat>)

impl<'i> VectorTrait<'i> for Vector<Vector<Point>>

type Arg = Vector<Point>

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Vector<Point>)

fn insert(&mut self, index: size_t, val: Vector<Point>) -> Result<()>

fn set(&mut self, index: size_t, val: Vector<Point>) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<Point>)

impl<'i> VectorTrait<'i> for Vector<Vector<Point2f>>

type Arg = Vector<Point2f>

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Vector<Point2f>)

fn insert(&mut self, index: size_t, val: Vector<Point2f>) -> Result<()>

fn set(&mut self, index: size_t, val: Vector<Point2f>) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<Point2f>)

impl<'i> VectorTrait<'i> for Vector<Vector<Point3d>>

type Arg = Vector<Point3d>

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Vector<Point3d>)

fn insert(&mut self, index: size_t, val: Vector<Point3d>) -> Result<()>

fn set(&mut self, index: size_t, val: Vector<Point3d>) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<Point3d>)

impl<'i> VectorTrait<'i> for Vector<Vector<Point3f>>

type Arg = Vector<Point3f>

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Vector<Point3f>)

fn insert(&mut self, index: size_t, val: Vector<Point3f>) -> Result<()>

fn set(&mut self, index: size_t, val: Vector<Point3f>) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<Point3f>)

impl<'i> VectorTrait<'i> for Vector<Vector<Point3i>>

type Arg = Vector<Point3i>

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Vector<Point3i>)

fn insert(&mut self, index: size_t, val: Vector<Point3i>) -> Result<()>

fn set(&mut self, index: size_t, val: Vector<Point3i>) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<Point3i>)

impl<'i> VectorTrait<'i> for Vector<Vector<Vec2i>>

type Arg = Vector<Vec2i>

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Vector<Vec2i>)

fn insert(&mut self, index: size_t, val: Vector<Vec2i>) -> Result<()>

fn set(&mut self, index: size_t, val: Vector<Vec2i>) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<Vec2i>)

impl<'i> VectorTrait<'i> for Vector<Vector<MatShape>>

type Arg = Vector<MatShape>

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Vector<MatShape>)

fn insert(&mut self, index: size_t, val: Vector<MatShape>) -> Result<()>

fn set(&mut self, index: size_t, val: Vector<MatShape>) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Vector<MatShape>)

impl<'i> VectorTrait<'i> for Vector<DPMDetector_ObjectDetection>

type Arg = DPMDetector_ObjectDetection

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: DPMDetector_ObjectDetection)

fn insert(
    &mut self,
    index: size_t,
    val: DPMDetector_ObjectDetection
) -> Result<()>

fn set(&mut self, index: size_t, val: DPMDetector_ObjectDetection) -> Result<()>

unsafe fn set_unchecked(
    &mut self,
    index: size_t,
    val: DPMDetector_ObjectDetection
)

impl<'i> VectorTrait<'i> for Vector<FacemarkAAM_Config>

type Arg = FacemarkAAM_Config

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: FacemarkAAM_Config)

fn insert(&mut self, index: size_t, val: FacemarkAAM_Config) -> Result<()>

fn set(&mut self, index: size_t, val: FacemarkAAM_Config) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: FacemarkAAM_Config)

impl<'i> VectorTrait<'i> for Vector<FacemarkAAM_Model_Texture>

type Arg = FacemarkAAM_Model_Texture

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: FacemarkAAM_Model_Texture)

fn insert(
    &mut self,
    index: size_t,
    val: FacemarkAAM_Model_Texture
) -> Result<()>

fn set(&mut self, index: size_t, val: FacemarkAAM_Model_Texture) -> Result<()>

unsafe fn set_unchecked(
    &mut self,
    index: size_t,
    val: FacemarkAAM_Model_Texture
)

impl<'i> VectorTrait<'i> for Vector<KeyLine>

type Arg = KeyLine

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: KeyLine)

fn insert(&mut self, index: size_t, val: KeyLine) -> Result<()>

fn set(&mut self, index: size_t, val: KeyLine) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: KeyLine)

impl<'i> VectorTrait<'i> for Vector<DTrees_Node>

type Arg = DTrees_Node

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: DTrees_Node)

fn insert(&mut self, index: size_t, val: DTrees_Node) -> Result<()>

fn set(&mut self, index: size_t, val: DTrees_Node) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: DTrees_Node)

impl<'i> VectorTrait<'i> for Vector<DTrees_Split>

type Arg = DTrees_Split

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: DTrees_Split)

fn insert(&mut self, index: size_t, val: DTrees_Split) -> Result<()>

fn set(&mut self, index: size_t, val: DTrees_Split) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: DTrees_Split)

impl<'i> VectorTrait<'i> for Vector<DetectionBasedTracker_ExtObject>

type Arg = DetectionBasedTracker_ExtObject

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: DetectionBasedTracker_ExtObject)

fn insert(
    &mut self,
    index: size_t,
    val: DetectionBasedTracker_ExtObject
) -> Result<()>

fn set(
    &mut self,
    index: size_t,
    val: DetectionBasedTracker_ExtObject
) -> Result<()>

unsafe fn set_unchecked(
    &mut self,
    index: size_t,
    val: DetectionBasedTracker_ExtObject
)

impl<'i> VectorTrait<'i> for Vector<DetectionROI>

type Arg = DetectionROI

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: DetectionROI)

fn insert(&mut self, index: size_t, val: DetectionROI) -> Result<()>

fn set(&mut self, index: size_t, val: DetectionROI) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: DetectionROI)

impl<'i> VectorTrait<'i> for Vector<Detail_CameraParams>

type Arg = Detail_CameraParams

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Detail_CameraParams)

fn insert(&mut self, index: size_t, val: Detail_CameraParams) -> Result<()>

fn set(&mut self, index: size_t, val: Detail_CameraParams) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Detail_CameraParams)

impl<'i> VectorTrait<'i> for Vector<Detail_ImageFeatures>

type Arg = Detail_ImageFeatures

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Detail_ImageFeatures)

fn insert(&mut self, index: size_t, val: Detail_ImageFeatures) -> Result<()>

fn set(&mut self, index: size_t, val: Detail_ImageFeatures) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Detail_ImageFeatures)

impl<'i> VectorTrait<'i> for Vector<Detail_MatchesInfo>

type Arg = Detail_MatchesInfo

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Detail_MatchesInfo)

fn insert(&mut self, index: size_t, val: Detail_MatchesInfo) -> Result<()>

fn set(&mut self, index: size_t, val: Detail_MatchesInfo) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Detail_MatchesInfo)

impl<'i> VectorTrait<'i> for Vector<ERStat>

type Arg = ERStat

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: ERStat)

fn insert(&mut self, index: size_t, val: ERStat) -> Result<()>

fn set(&mut self, index: size_t, val: ERStat) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: ERStat)

impl<'i> VectorTrait<'i> for Vector<VideoCapture>

type Arg = VideoCapture

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: VideoCapture)

fn insert(&mut self, index: size_t, val: VideoCapture) -> Result<()>

fn set(&mut self, index: size_t, val: VideoCapture) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: VideoCapture)

impl<'i> VectorTrait<'i> for Vector<Elliptic_KeyPoint>

type Arg = Elliptic_KeyPoint

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Elliptic_KeyPoint)

fn insert(&mut self, index: size_t, val: Elliptic_KeyPoint) -> Result<()>

fn set(&mut self, index: size_t, val: Elliptic_KeyPoint) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Elliptic_KeyPoint)

impl<'i> VectorTrait<'i> for Vector<String>

type Arg = &'i str

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: &str)

fn insert(&mut self, index: size_t, val: &str) -> Result<()>

fn set(&mut self, index: size_t, val: &str) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: &str)

impl<'i> VectorTrait<'i> for Vector<Point>

type Arg = Point

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Point)

fn insert(&mut self, index: size_t, val: Point) -> Result<()>

fn set(&mut self, index: size_t, val: Point) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Point)

impl<'i> VectorTrait<'i> for Vector<Point2d>

type Arg = Point2d

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Point2d)

fn insert(&mut self, index: size_t, val: Point2d) -> Result<()>

fn set(&mut self, index: size_t, val: Point2d) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Point2d)

impl<'i> VectorTrait<'i> for Vector<Point2f>

type Arg = Point2f

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Point2f)

fn insert(&mut self, index: size_t, val: Point2f) -> Result<()>

fn set(&mut self, index: size_t, val: Point2f) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Point2f)

impl<'i> VectorTrait<'i> for Vector<Point3d>

type Arg = Point3d

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Point3d)

fn insert(&mut self, index: size_t, val: Point3d) -> Result<()>

fn set(&mut self, index: size_t, val: Point3d) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Point3d)

impl<'i> VectorTrait<'i> for Vector<Point3f>

type Arg = Point3f

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Point3f)

fn insert(&mut self, index: size_t, val: Point3f) -> Result<()>

fn set(&mut self, index: size_t, val: Point3f) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Point3f)

impl<'i> VectorTrait<'i> for Vector<Point3i>

type Arg = Point3i

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Point3i)

fn insert(&mut self, index: size_t, val: Point3i) -> Result<()>

fn set(&mut self, index: size_t, val: Point3i) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Point3i)

impl<'i> VectorTrait<'i> for Vector<Rect>

type Arg = Rect

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Rect)

fn insert(&mut self, index: size_t, val: Rect) -> Result<()>

fn set(&mut self, index: size_t, val: Rect) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Rect)

impl<'i> VectorTrait<'i> for Vector<Rect2d>

type Arg = Rect2d

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Rect2d)

fn insert(&mut self, index: size_t, val: Rect2d) -> Result<()>

fn set(&mut self, index: size_t, val: Rect2d) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Rect2d)

impl<'i> VectorTrait<'i> for Vector<Scalar>

type Arg = Scalar

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Scalar)

fn insert(&mut self, index: size_t, val: Scalar) -> Result<()>

fn set(&mut self, index: size_t, val: Scalar) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Scalar)

impl<'i> VectorTrait<'i> for Vector<Size>

type Arg = Size

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Size)

fn insert(&mut self, index: size_t, val: Size) -> Result<()>

fn set(&mut self, index: size_t, val: Size) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Size)

impl<'i> VectorTrait<'i> for Vector<Vec2i>

type Arg = Vec2i

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Vec2i)

fn insert(&mut self, index: size_t, val: Vec2i) -> Result<()>

fn set(&mut self, index: size_t, val: Vec2i) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Vec2i)

impl<'i> VectorTrait<'i> for Vector<Vec3d>

type Arg = Vec3d

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Vec3d)

fn insert(&mut self, index: size_t, val: Vec3d) -> Result<()>

fn set(&mut self, index: size_t, val: Vec3d) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Vec3d)

impl<'i> VectorTrait<'i> for Vector<Vec3f>

type Arg = Vec3f

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Vec3f)

fn insert(&mut self, index: size_t, val: Vec3f) -> Result<()>

fn set(&mut self, index: size_t, val: Vec3f) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Vec3f)

impl<'i> VectorTrait<'i> for Vector<Vec3i>

type Arg = Vec3i

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Vec3i)

fn insert(&mut self, index: size_t, val: Vec3i) -> Result<()>

fn set(&mut self, index: size_t, val: Vec3i) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Vec3i)

impl<'i> VectorTrait<'i> for Vector<Vec4f>

type Arg = Vec4f

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Vec4f)

fn insert(&mut self, index: size_t, val: Vec4f) -> Result<()>

fn set(&mut self, index: size_t, val: Vec4f) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Vec4f)

impl<'i> VectorTrait<'i> for Vector<Vec4i>

type Arg = Vec4i

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Vec4i)

fn insert(&mut self, index: size_t, val: Vec4i) -> Result<()>

fn set(&mut self, index: size_t, val: Vec4i) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Vec4i)

impl<'i> VectorTrait<'i> for Vector<Vec6f>

type Arg = Vec6f

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Vec6f)

fn insert(&mut self, index: size_t, val: Vec6f) -> Result<()>

fn set(&mut self, index: size_t, val: Vec6f) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Vec6f)

impl<'i> VectorTrait<'i> for Vector<Pose3DPtr>

type Arg = Pose3DPtr

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: Pose3DPtr)

fn insert(&mut self, index: size_t, val: Pose3DPtr) -> Result<()>

fn set(&mut self, index: size_t, val: Pose3DPtr) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: Pose3DPtr)

impl<'i> VectorTrait<'i> for Vector<size_t>

type Arg = size_t

fn with_capacity(capacity: size_t) -> Self

fn push(&mut self, val: size_t)

fn insert(&mut self, index: size_t, val: size_t) -> Result<()>

fn set(&mut self, index: size_t, val: size_t) -> Result<()>

unsafe fn set_unchecked(&mut self, index: size_t, val: size_t)

Loading content...