vendor/tabled/src/settings/object/mod.rs - toolchain/rustc - Git at Google

 //! This module contains a list of primitives that implement a [`Object`] trait.
 //! They help to locate a necessary segment on a [`Table`].
 //!
 //! [`Table`]: crate::Table

 mod cell;
 mod columns;
 mod frame;
 mod rows;
 mod segment;
 pub(crate) mod util;

 use std::{collections::HashSet, marker::PhantomData};

 use self::segment::SectorCellsIter;

 use crate::{
     grid::config::{Entity, EntityIterator},
     grid::records::{ExactRecords, Records},
 };

 pub use cell::{Cell, EntityOnce};
 pub use columns::{Column, Columns, ColumnsIter, FirstColumn, LastColumn, LastColumnOffset};
 pub use frame::{Frame, FrameIter};
 pub use rows::{FirstRow, LastRow, LastRowOffset, Row, Rows, RowsIter};
 pub use segment::{SectorIter, Segment, SegmentAll};

 /// Object helps to locate a necessary part of a [`Table`].
 ///
 /// [`Table`]: crate::Table
 pub trait Object<R> {
     /// An [`Iterator`] which returns a list of cells.
     type Iter: Iterator<Item = Entity>;

     /// Cells returns a set of coordinates of cells.
     fn cells(&self, records: &R) -> Self::Iter;

     /// Combines cells.
     /// It doesn't repeat cells.
     fn and<O>(self, rhs: O) -> UnionCombination<Self, O, R>
     where
         Self: Sized,
     {
         UnionCombination::new(self, rhs)
     }

     /// Excludes rhs cells from this cells.
     fn not<O>(self, rhs: O) -> DiffCombination<Self, O, R>
     where
         Self: Sized,
     {
         DiffCombination::new(self, rhs)
     }

     /// Returns cells which are present in both [`Object`]s only.
     fn intersect<O>(self, rhs: O) -> IntersectionCombination<Self, O, R>
     where
         Self: Sized,
     {
         IntersectionCombination::new(self, rhs)
     }

     /// Returns cells which are not present in target [`Object`].
     fn inverse(self) -> InversionCombination<Self, R>
     where
         Self: Sized,
     {
         InversionCombination::new(self)
     }
 }

 /// Combination struct used for chaining [`Object`]'s.
 ///
 /// Combines 2 sets of cells into one.
 ///
 /// Duplicates are removed from the output set.
 #[derive(Debug)]
 pub struct UnionCombination<L, R, I> {
     lhs: L,
     rhs: R,
     _records: PhantomData<I>,
 }

 impl<L, R, I> UnionCombination<L, R, I> {
     fn new(lhs: L, rhs: R) -> Self {
         Self {
             lhs,
             rhs,
             _records: PhantomData,
         }
     }
 }

 impl<I, L, R> Object<I> for UnionCombination<L, R, I>
 where
     L: Object<I>,
     R: Object<I>,
     I: Records + ExactRecords,
 {
     type Iter = UnionIter<L::Iter, R::Iter>;

     fn cells(&self, records: &I) -> Self::Iter {
         let lhs = self.lhs.cells(records);
         let rhs = self.rhs.cells(records);

         UnionIter::new(lhs, rhs, records.count_rows(), records.count_columns())
     }
 }

 /// Difference struct used for chaining [`Object`]'s.
 ///
 /// Returns cells from 1st set with removed ones from the 2nd set.
 #[derive(Debug)]
 pub struct DiffCombination<L, R, I> {
     lhs: L,
     rhs: R,
     _records: PhantomData<I>,
 }

 impl<L, R, I> DiffCombination<L, R, I> {
     fn new(lhs: L, rhs: R) -> Self {
         Self {
             lhs,
             rhs,
             _records: PhantomData,
         }
     }
 }

 impl<I, L, R> Object<I> for DiffCombination<L, R, I>
 where
     L: Object<I>,
     R: Object<I>,
     I: Records + ExactRecords,
 {
     type Iter = DiffIter<L::Iter>;

     fn cells(&self, records: &I) -> Self::Iter {
         let lhs = self.lhs.cells(records);
         let rhs = self.rhs.cells(records);

         DiffIter::new(lhs, rhs, records.count_rows(), records.count_columns())
     }
 }

 /// Intersection struct used for chaining [`Object`]'s.
 ///
 /// Returns cells which are present in 2 sets.
 /// But not in one of them
 #[derive(Debug)]
 pub struct IntersectionCombination<L, R, I> {
     lhs: L,
     rhs: R,
     _records: PhantomData<I>,
 }

 impl<L, R, I> IntersectionCombination<L, R, I> {
     fn new(lhs: L, rhs: R) -> Self {
         Self {
             lhs,
             rhs,
             _records: PhantomData,
         }
     }
 }

 impl<I, L, R> Object<I> for IntersectionCombination<L, R, I>
 where
     L: Object<I>,
     R: Object<I>,
     I: Records + ExactRecords,
 {
     type Iter = IntersectIter<L::Iter>;

     fn cells(&self, records: &I) -> Self::Iter {
         let lhs = self.lhs.cells(records);
         let rhs = self.rhs.cells(records);

         IntersectIter::new(lhs, rhs, records.count_rows(), records.count_columns())
     }
 }

 /// Inversion struct used for chaining [`Object`]'s.
 ///
 /// Returns cells which are present in 2 sets.
 /// But not in one of them
 #[derive(Debug)]
 pub struct InversionCombination<O, I> {
     obj: O,
     _records: PhantomData<I>,
 }

 impl<O, I> InversionCombination<O, I> {
     fn new(obj: O) -> Self {
         Self {
             obj,
             _records: PhantomData,
         }
     }
 }

 impl<I, O> Object<I> for InversionCombination<O, I>
 where
     O: Object<I>,
     I: Records + ExactRecords,
 {
     type Iter = InversionIter;

     fn cells(&self, records: &I) -> Self::Iter {
         let obj = self.obj.cells(records);

         InversionIter::new(obj, records.count_rows(), records.count_columns())
     }
 }

 /// An [`Iterator`] which goes over a combination [`Object::Iter`].
 #[derive(Debug)]
 pub struct UnionIter<L, R> {
     lhs: Option<L>,
     rhs: R,
     seen: HashSet<(usize, usize)>,
     current: Option<EntityIterator>,
     count_rows: usize,
     count_cols: usize,
 }

 impl<L, R> UnionIter<L, R>
 where
     L: Iterator<Item = Entity>,
     R: Iterator<Item = Entity>,
 {
     fn new(lhs: L, rhs: R, count_rows: usize, count_cols: usize) -> Self {
         let size = match lhs.size_hint() {
             (s1, Some(s2)) if s1 == s2 => s1,
             _ => 0,
         };

         Self {
             lhs: Some(lhs),
             rhs,
             seen: HashSet::with_capacity(size),
             current: None,
             count_rows,
             count_cols,
         }
     }
 }

 impl<L, R> Iterator for UnionIter<L, R>
 where
     L: Iterator<Item = Entity>,
     R: Iterator<Item = Entity>,
 {
     type Item = Entity;

     fn next(&mut self) -> Option<Self::Item> {
         if let Some(iter) = self.current.as_mut() {
             for p in iter.by_ref() {
                 if self.lhs.is_none() && self.seen.contains(&p) {
                     continue;
                 }

                 let _ = self.seen.insert(p);
                 return Some(Entity::Cell(p.0, p.1));
             }
         }

         if let Some(lhs) = self.lhs.as_mut() {
             for entity in lhs.by_ref() {
                 let mut iter = entity.iter(self.count_rows, self.count_cols);
                 if let Some(p) = iter.by_ref().next() {
                     let _ = self.seen.insert(p);
                     self.current = Some(iter);
                     return Some(Entity::Cell(p.0, p.1));
                 }
             }

             self.lhs = None;
         }

         for entity in self.rhs.by_ref() {
             let mut iter = entity.iter(self.count_rows, self.count_cols);

             for p in iter.by_ref() {
                 if !self.seen.contains(&p) {
                     let _ = self.seen.insert(p);
                     self.current = Some(iter);
                     return Some(Entity::Cell(p.0, p.1));
                 }
             }
         }

         None
     }
 }

 /// An [`Iterator`] which goes over only cells which are present in first [`Object::Iter`] but not second.
 #[derive(Debug)]
 pub struct DiffIter<L> {
     lhs: L,
     seen: HashSet<(usize, usize)>,
     count_rows: usize,
     count_cols: usize,
     current: Option<EntityIterator>,
 }

 impl<L> DiffIter<L>
 where
     L: Iterator<Item = Entity>,
 {
     fn new<R>(lhs: L, rhs: R, count_rows: usize, count_cols: usize) -> Self
     where
         R: Iterator<Item = Entity>,
     {
         let size = match rhs.size_hint() {
             (s1, Some(s2)) if s1 == s2 => s1,
             _ => 0,
         };

         let mut seen = HashSet::with_capacity(size);
         for entity in rhs {
             seen.extend(entity.iter(count_rows, count_cols));
         }

         Self {
             lhs,
             seen,
             count_rows,
             count_cols,
             current: None,
         }
     }
 }

 impl<L> Iterator for DiffIter<L>
 where
     L: Iterator<Item = Entity>,
 {
     type Item = Entity;

     fn next(&mut self) -> Option<Self::Item> {
         if let Some(iter) = self.current.as_mut() {
             for p in iter.by_ref() {
                 if !self.seen.contains(&p) {
                     return Some(Entity::Cell(p.0, p.1));
                 }
             }
         }

         for entity in self.lhs.by_ref() {
             let mut iter = entity.iter(self.count_rows, self.count_cols);

             for p in iter.by_ref() {
                 if !self.seen.contains(&p) {
                     self.current = Some(iter);
                     return Some(Entity::Cell(p.0, p.1));
                 }
             }
         }

         None
     }
 }

 /// An [`Iterator`] which goes goes over cells which are present in both [`Object::Iter`]ators.
 #[derive(Debug)]
 pub struct IntersectIter<L> {
     lhs: L,
     seen: HashSet<(usize, usize)>,
     count_rows: usize,
     count_cols: usize,
     current: Option<EntityIterator>,
 }

 impl<L> IntersectIter<L>
 where
     L: Iterator<Item = Entity>,
 {
     fn new<R>(lhs: L, rhs: R, count_rows: usize, count_cols: usize) -> Self
     where
         R: Iterator<Item = Entity>,
     {
         let size = match rhs.size_hint() {
             (s1, Some(s2)) if s1 == s2 => s1,
             _ => 0,
         };

         let mut seen = HashSet::with_capacity(size);
         for entity in rhs {
             seen.extend(entity.iter(count_rows, count_cols));
         }

         Self {
             lhs,
             seen,
             count_rows,
             count_cols,
             current: None,
         }
     }
 }

 impl<L> Iterator for IntersectIter<L>
 where
     L: Iterator<Item = Entity>,
 {
     type Item = Entity;

     fn next(&mut self) -> Option<Self::Item> {
         if let Some(iter) = self.current.as_mut() {
             for p in iter.by_ref() {
                 if self.seen.contains(&p) {
                     return Some(Entity::Cell(p.0, p.1));
                 }
             }
         }

         for entity in self.lhs.by_ref() {
             let mut iter = entity.iter(self.count_rows, self.count_cols);

             for p in iter.by_ref() {
                 if self.seen.contains(&p) {
                     self.current = Some(iter);
                     return Some(Entity::Cell(p.0, p.1));
                 }
             }
         }

         None
     }
 }

 /// An [`Iterator`] which goes goes over cells which are not present an [`Object::Iter`]ator.
 #[derive(Debug)]
 pub struct InversionIter {
     all: SectorCellsIter,
     seen: HashSet<(usize, usize)>,
 }

 impl InversionIter {
     fn new<O>(obj: O, count_rows: usize, count_columns: usize) -> Self
     where
         O: Iterator<Item = Entity>,
     {
         let size = match obj.size_hint() {
             (s1, Some(s2)) if s1 == s2 => s1,
             _ => 0,
         };

         let mut seen = HashSet::with_capacity(size);
         for entity in obj {
             seen.extend(entity.iter(count_rows, count_columns));
         }

         let all = SectorCellsIter::new(0, count_rows, 0, count_columns);

         Self { all, seen }
     }
 }

 impl Iterator for InversionIter {
     type Item = Entity;

     fn next(&mut self) -> Option<Self::Item> {
         for p in self.all.by_ref() {
             if !self.seen.contains(&p) {
                 return Some(Entity::Cell(p.0, p.1));
             }
         }

         None
     }
 }

 #[cfg(test)]
 mod tests {
     use crate::grid::records::vec_records::VecRecords;

     use super::*;

     #[test]
     fn cell_test() {
         assert_eq!(vec_cells((0, 0), 2, 3), [Entity::Cell(0, 0)]);
         assert_eq!(vec_cells((1, 1), 2, 3), [Entity::Cell(1, 1)]);
         assert_eq!(vec_cells((1, 1), 0, 0), [Entity::Cell(1, 1)]);
         assert_eq!(vec_cells((1, 100), 2, 3), [Entity::Cell(1, 100)]);
         assert_eq!(vec_cells((100, 1), 2, 3), [Entity::Cell(100, 1)]);
     }

     #[test]
     fn columns_test() {
         assert_eq!(
             vec_cells(Columns::new(..), 2, 3),
             [Entity::Column(0), Entity::Column(1), Entity::Column(2)]
         );
         assert_eq!(
             vec_cells(Columns::new(1..), 2, 3),
             [Entity::Column(1), Entity::Column(2)]
         );
         assert_eq!(vec_cells(Columns::new(2..), 2, 3), [Entity::Column(2)]);
         assert_eq!(vec_cells(Columns::new(3..), 2, 3), []);
         assert_eq!(vec_cells(Columns::new(3..), 0, 0), []);
         assert_eq!(vec_cells(Columns::new(0..1), 2, 3), [Entity::Column(0)]);
         assert_eq!(vec_cells(Columns::new(1..2), 2, 3), [Entity::Column(1)]);
         assert_eq!(vec_cells(Columns::new(2..3), 2, 3), [Entity::Column(2)]);
         assert_eq!(vec_cells(Columns::new(..), 0, 0), []);
         assert_eq!(vec_cells(Columns::new(..), 2, 0), []);
         assert_eq!(vec_cells(Columns::new(..), 0, 3), []);
     }

     #[test]
     fn first_column_test() {
         assert_eq!(vec_cells(Columns::first(), 5, 2), [Entity::Column(0)]);
         assert_eq!(vec_cells(Columns::first(), 0, 0), []);
         assert_eq!(vec_cells(Columns::first(), 10, 0), []);
         assert_eq!(vec_cells(Columns::first(), 0, 10), []);
     }

     #[test]
     fn last_column_test() {
         assert_eq!(vec_cells(Columns::last(), 5, 2), [Entity::Column(1)]);
         assert_eq!(vec_cells(Columns::last(), 5, 29), [Entity::Column(28)]);
         assert_eq!(vec_cells(Columns::last(), 0, 0), []);
         assert_eq!(vec_cells(Columns::last(), 10, 0), []);
         assert_eq!(vec_cells(Columns::last(), 0, 10), []);
     }

     #[test]
     fn last_column_sub_test() {
         assert_eq!(vec_cells(Columns::last(), 5, 2), [Entity::Column(1)]);
         assert_eq!(vec_cells(Columns::last() - 0, 5, 2), [Entity::Column(1)]);
         assert_eq!(vec_cells(Columns::last() - 1, 5, 2), [Entity::Column(0)]);
         assert_eq!(vec_cells(Columns::last() - 2, 5, 2), []);
         assert_eq!(vec_cells(Columns::last() - 100, 5, 2), []);
     }

     #[test]
     fn first_column_add_test() {
         assert_eq!(vec_cells(Columns::first(), 5, 2), [Entity::Column(0)]);
         assert_eq!(vec_cells(Columns::first() + 0, 5, 2), [Entity::Column(0)]);
         assert_eq!(vec_cells(Columns::first() + 1, 5, 2), [Entity::Column(1)]);
         assert_eq!(vec_cells(Columns::first() + 2, 5, 2), [Entity::Column(2)]);
         assert_eq!(
             vec_cells(Columns::first() + 100, 5, 2),
             [Entity::Column(100)]
         );
     }

     #[test]
     fn rows_test() {
         assert_eq!(
             vec_cells(Rows::new(..), 2, 3),
             [Entity::Row(0), Entity::Row(1)]
         );
         assert_eq!(vec_cells(Rows::new(1..), 2, 3), [Entity::Row(1)]);
         assert_eq!(vec_cells(Rows::new(2..), 2, 3), []);
         assert_eq!(vec_cells(Rows::new(2..), 0, 0), []);
         assert_eq!(vec_cells(Rows::new(0..1), 2, 3), [Entity::Row(0)],);
         assert_eq!(vec_cells(Rows::new(1..2), 2, 3), [Entity::Row(1)],);
         assert_eq!(vec_cells(Rows::new(..), 0, 0), []);
         assert_eq!(vec_cells(Rows::new(..), 0, 3), []);
         assert_eq!(
             vec_cells(Rows::new(..), 2, 0),
             [Entity::Row(0), Entity::Row(1)]
         );
     }

     #[test]
     fn last_row_test() {
         assert_eq!(vec_cells(Rows::last(), 5, 2), [Entity::Row(4)]);
         assert_eq!(vec_cells(Rows::last(), 100, 2), [Entity::Row(99)]);
         assert_eq!(vec_cells(Rows::last(), 0, 0), []);
         assert_eq!(vec_cells(Rows::last(), 5, 0), []);
         assert_eq!(vec_cells(Rows::last(), 0, 2), []);
     }

     #[test]
     fn first_row_test() {
         assert_eq!(vec_cells(Rows::first(), 5, 2), [Entity::Row(0)]);
         assert_eq!(vec_cells(Rows::first(), 100, 2), [Entity::Row(0)]);
         assert_eq!(vec_cells(Rows::first(), 0, 0), []);
         assert_eq!(vec_cells(Rows::first(), 5, 0), []);
         assert_eq!(vec_cells(Rows::first(), 0, 2), []);
     }

     #[test]
     fn last_row_sub_test() {
         assert_eq!(vec_cells(Rows::last(), 5, 2), [Entity::Row(4)]);
         assert_eq!(vec_cells(Rows::last() - 0, 5, 2), [Entity::Row(4)]);
         assert_eq!(vec_cells(Rows::last() - 1, 5, 2), [Entity::Row(3)]);
         assert_eq!(vec_cells(Rows::last() - 2, 5, 2), [Entity::Row(2)]);
         assert_eq!(vec_cells(Rows::last() - 3, 5, 2), [Entity::Row(1)]);
         assert_eq!(vec_cells(Rows::last() - 4, 5, 2), [Entity::Row(0)]);
         assert_eq!(vec_cells(Rows::last() - 5, 5, 2), []);
         assert_eq!(vec_cells(Rows::last() - 100, 5, 2), []);
         assert_eq!(vec_cells(Rows::last() - 1, 0, 0), []);
         assert_eq!(vec_cells(Rows::last() - 1, 5, 0), []);
         assert_eq!(vec_cells(Rows::last() - 1, 0, 2), []);
     }

     #[test]
     fn first_row_add_test() {
         assert_eq!(vec_cells(Rows::first(), 5, 2), [Entity::Row(0)]);
         assert_eq!(vec_cells(Rows::first() + 0, 5, 2), [Entity::Row(0)]);
         assert_eq!(vec_cells(Rows::first() + 1, 5, 2), [Entity::Row(1)]);
         assert_eq!(vec_cells(Rows::first() + 2, 5, 2), [Entity::Row(2)]);
         assert_eq!(vec_cells(Rows::first() + 3, 5, 2), [Entity::Row(3)]);
         assert_eq!(vec_cells(Rows::first() + 4, 5, 2), [Entity::Row(4)]);
         assert_eq!(vec_cells(Rows::first() + 5, 5, 2), [Entity::Row(5)]);
         assert_eq!(vec_cells(Rows::first() + 100, 5, 2), [Entity::Row(100)]);
         assert_eq!(vec_cells(Rows::first() + 1, 0, 0), [Entity::Row(1)]);
         assert_eq!(vec_cells(Rows::first() + 1, 5, 0), [Entity::Row(1)]);
         assert_eq!(vec_cells(Rows::first() + 1, 0, 2), [Entity::Row(1)]);
     }

     #[test]
     fn frame_test() {
         assert_eq!(
             vec_cells(Frame, 2, 3),
             [
                 Entity::Cell(0, 0),
                 Entity::Cell(0, 1),
                 Entity::Cell(0, 2),
                 Entity::Cell(1, 0),
                 Entity::Cell(1, 1),
                 Entity::Cell(1, 2)
             ]
         );
         assert_eq!(vec_cells(Frame, 0, 0), []);
         assert_eq!(vec_cells(Frame, 2, 0), []);
         assert_eq!(vec_cells(Frame, 0, 2), []);
     }

     #[test]
     fn segment_test() {
         assert_eq!(
             vec_cells(Segment::new(.., ..), 2, 3),
             [
                 Entity::Cell(0, 0),
                 Entity::Cell(0, 1),
                 Entity::Cell(0, 2),
                 Entity::Cell(1, 0),
                 Entity::Cell(1, 1),
                 Entity::Cell(1, 2)
             ]
         );
         assert_eq!(
             vec_cells(Segment::new(1.., ..), 2, 3),
             [Entity::Cell(1, 0), Entity::Cell(1, 1), Entity::Cell(1, 2)]
         );
         assert_eq!(vec_cells(Segment::new(2.., ..), 2, 3), []);

         assert_eq!(
             vec_cells(Segment::new(.., 1..), 2, 3),
             [
                 Entity::Cell(0, 1),
                 Entity::Cell(0, 2),
                 Entity::Cell(1, 1),
                 Entity::Cell(1, 2)
             ]
         );
         assert_eq!(
             vec_cells(Segment::new(.., 2..), 2, 3),
             [Entity::Cell(0, 2), Entity::Cell(1, 2)]
         );
         assert_eq!(vec_cells(Segment::new(.., 3..), 2, 3), []);

         assert_eq!(
             vec_cells(Segment::new(1.., 1..), 2, 3),
             [Entity::Cell(1, 1), Entity::Cell(1, 2)]
         );
         assert_eq!(
             vec_cells(Segment::new(1..2, 1..2), 2, 3),
             [Entity::Cell(1, 1)]
         );

         assert_eq!(vec_cells(Segment::new(5.., 5..), 2, 3), []);
     }

     #[test]
     fn object_and_test() {
         assert_eq!(
             vec_cells(Cell::new(0, 0).and(Cell::new(0, 0)), 2, 3),
             [Entity::Cell(0, 0)]
         );
         assert_eq!(
             vec_cells(Cell::new(0, 0).and(Cell::new(1, 2)), 2, 3),
             [Entity::Cell(0, 0), Entity::Cell(1, 2)]
         );
         assert_eq!(vec_cells(Cell::new(0, 0).and(Cell::new(1, 2)), 0, 0), []);
     }

     #[test]
     fn object_not_test() {
         assert_eq!(vec_cells(Rows::first().not(Cell::new(0, 0)), 0, 0), []);
         assert_eq!(vec_cells(Cell::new(0, 0).not(Cell::new(0, 0)), 2, 3), []);
         assert_eq!(
             vec_cells(Rows::first().not(Cell::new(0, 0)), 2, 3),
             [Entity::Cell(0, 1), Entity::Cell(0, 2)]
         );
         assert_eq!(
             vec_cells(Columns::single(1).not(Rows::single(1)), 3, 3),
             [Entity::Cell(0, 1), Entity::Cell(2, 1)]
         );
         assert_eq!(
             vec_cells(Rows::single(1).not(Columns::single(1)), 3, 3),
             [Entity::Cell(1, 0), Entity::Cell(1, 2)]
         );
     }

     #[test]
     fn object_intersect_test() {
         assert_eq!(
             vec_cells(Rows::first().intersect(Cell::new(0, 0)), 0, 0),
             []
         );
         assert_eq!(
             vec_cells(Segment::all().intersect(Rows::single(1)), 2, 3),
             [Entity::Cell(1, 0), Entity::Cell(1, 1), Entity::Cell(1, 2)]
         );
         assert_eq!(
             vec_cells(Cell::new(0, 0).intersect(Cell::new(0, 0)), 2, 3),
             [Entity::Cell(0, 0)]
         );
         assert_eq!(
             vec_cells(Rows::first().intersect(Cell::new(0, 0)), 2, 3),
             [Entity::Cell(0, 0)]
         );
         // maybe we somehow shall not limit the rows/columns by the max count?
         assert_eq!(
             vec_cells(Rows::single(1).intersect(Columns::single(1)), 2, 1),
             []
         );
     }

     #[test]
     fn object_inverse_test() {
         assert_eq!(vec_cells(Segment::all().inverse(), 2, 3), []);
         assert_eq!(
             vec_cells(Cell::new(0, 0).inverse(), 2, 3),
             [
                 Entity::Cell(0, 1),
                 Entity::Cell(0, 2),
                 Entity::Cell(1, 0),
                 Entity::Cell(1, 1),
                 Entity::Cell(1, 2)
             ]
         );
         assert_eq!(
             vec_cells(Rows::first().inverse(), 2, 3),
             [Entity::Cell(1, 0), Entity::Cell(1, 1), Entity::Cell(1, 2)]
         );
         assert_eq!(vec_cells(Rows::first().inverse(), 0, 0), []);
     }

     fn vec_cells<O: Object<VecRecords<String>>>(
         o: O,
         count_rows: usize,
         count_cols: usize,
     ) -> Vec<Entity> {
         let data = vec![vec![String::default(); count_cols]; count_rows];
         let records = VecRecords::new(data);
         o.cells(&records).collect::<Vec<_>>()
     }
 }
	//! This module contains a list of primitives that implement a [`Object`] trait.
	//! They help to locate a necessary segment on a [`Table`].
	//!
	//! [`Table`]: crate::Table

	mod cell;
	mod columns;
	mod frame;
	mod rows;
	mod segment;
	pub(crate) mod util;

	use std::{collections::HashSet, marker::PhantomData};

	use self::segment::SectorCellsIter;

	use crate::{
	grid::config::{Entity, EntityIterator},
	grid::records::{ExactRecords, Records},
	};

	pub use cell::{Cell, EntityOnce};
	pub use columns::{Column, Columns, ColumnsIter, FirstColumn, LastColumn, LastColumnOffset};
	pub use frame::{Frame, FrameIter};
	pub use rows::{FirstRow, LastRow, LastRowOffset, Row, Rows, RowsIter};
	pub use segment::{SectorIter, Segment, SegmentAll};

	/// Object helps to locate a necessary part of a [`Table`].
	///
	/// [`Table`]: crate::Table
	pub trait Object<R> {
	/// An [`Iterator`] which returns a list of cells.
	type Iter: Iterator<Item = Entity>;

	/// Cells returns a set of coordinates of cells.
	fn cells(&self, records: &R) -> Self::Iter;

	/// Combines cells.
	/// It doesn't repeat cells.
	fn and<O>(self, rhs: O) -> UnionCombination<Self, O, R>
	where
	Self: Sized,
	{
	UnionCombination::new(self, rhs)
	}

	/// Excludes rhs cells from this cells.
	fn not<O>(self, rhs: O) -> DiffCombination<Self, O, R>
	where
	Self: Sized,
	{
	DiffCombination::new(self, rhs)
	}

	/// Returns cells which are present in both [`Object`]s only.
	fn intersect<O>(self, rhs: O) -> IntersectionCombination<Self, O, R>
	where
	Self: Sized,
	{
	IntersectionCombination::new(self, rhs)
	}

	/// Returns cells which are not present in target [`Object`].
	fn inverse(self) -> InversionCombination<Self, R>
	where
	Self: Sized,
	{
	InversionCombination::new(self)
	}
	}

	/// Combination struct used for chaining [`Object`]'s.
	///
	/// Combines 2 sets of cells into one.
	///
	/// Duplicates are removed from the output set.
	#[derive(Debug)]
	pub struct UnionCombination<L, R, I> {
	lhs: L,
	rhs: R,
	_records: PhantomData<I>,
	}

	impl<L, R, I> UnionCombination<L, R, I> {
	fn new(lhs: L, rhs: R) -> Self {
	Self {
	lhs,
	rhs,
	_records: PhantomData,
	}
	}
	}

	impl<I, L, R> Object<I> for UnionCombination<L, R, I>
	where
	L: Object<I>,
	R: Object<I>,
	I: Records + ExactRecords,
	{
	type Iter = UnionIter<L::Iter, R::Iter>;

	fn cells(&self, records: &I) -> Self::Iter {
	let lhs = self.lhs.cells(records);
	let rhs = self.rhs.cells(records);

	UnionIter::new(lhs, rhs, records.count_rows(), records.count_columns())
	}
	}

	/// Difference struct used for chaining [`Object`]'s.
	///
	/// Returns cells from 1st set with removed ones from the 2nd set.
	#[derive(Debug)]
	pub struct DiffCombination<L, R, I> {
	lhs: L,
	rhs: R,
	_records: PhantomData<I>,
	}

	impl<L, R, I> DiffCombination<L, R, I> {
	fn new(lhs: L, rhs: R) -> Self {
	Self {
	lhs,
	rhs,
	_records: PhantomData,
	}
	}
	}

	impl<I, L, R> Object<I> for DiffCombination<L, R, I>
	where
	L: Object<I>,
	R: Object<I>,
	I: Records + ExactRecords,
	{
	type Iter = DiffIter<L::Iter>;

	fn cells(&self, records: &I) -> Self::Iter {
	let lhs = self.lhs.cells(records);
	let rhs = self.rhs.cells(records);

	DiffIter::new(lhs, rhs, records.count_rows(), records.count_columns())
	}
	}

	/// Intersection struct used for chaining [`Object`]'s.
	///
	/// Returns cells which are present in 2 sets.
	/// But not in one of them
	#[derive(Debug)]
	pub struct IntersectionCombination<L, R, I> {
	lhs: L,
	rhs: R,
	_records: PhantomData<I>,
	}

	impl<L, R, I> IntersectionCombination<L, R, I> {
	fn new(lhs: L, rhs: R) -> Self {
	Self {
	lhs,
	rhs,
	_records: PhantomData,
	}
	}
	}

	impl<I, L, R> Object<I> for IntersectionCombination<L, R, I>
	where
	L: Object<I>,
	R: Object<I>,
	I: Records + ExactRecords,
	{
	type Iter = IntersectIter<L::Iter>;

	fn cells(&self, records: &I) -> Self::Iter {
	let lhs = self.lhs.cells(records);
	let rhs = self.rhs.cells(records);

	IntersectIter::new(lhs, rhs, records.count_rows(), records.count_columns())
	}
	}

	/// Inversion struct used for chaining [`Object`]'s.
	///
	/// Returns cells which are present in 2 sets.
	/// But not in one of them
	#[derive(Debug)]
	pub struct InversionCombination<O, I> {
	obj: O,
	_records: PhantomData<I>,
	}

	impl<O, I> InversionCombination<O, I> {
	fn new(obj: O) -> Self {
	Self {
	obj,
	_records: PhantomData,
	}
	}
	}

	impl<I, O> Object<I> for InversionCombination<O, I>
	where
	O: Object<I>,
	I: Records + ExactRecords,
	{
	type Iter = InversionIter;

	fn cells(&self, records: &I) -> Self::Iter {
	let obj = self.obj.cells(records);

	InversionIter::new(obj, records.count_rows(), records.count_columns())
	}
	}

	/// An [`Iterator`] which goes over a combination [`Object::Iter`].
	#[derive(Debug)]
	pub struct UnionIter<L, R> {
	lhs: Option<L>,
	rhs: R,
	seen: HashSet<(usize, usize)>,
	current: Option<EntityIterator>,
	count_rows: usize,
	count_cols: usize,
	}

	impl<L, R> UnionIter<L, R>
	where
	L: Iterator<Item = Entity>,
	R: Iterator<Item = Entity>,
	{
	fn new(lhs: L, rhs: R, count_rows: usize, count_cols: usize) -> Self {
	let size = match lhs.size_hint() {
	(s1, Some(s2)) if s1 == s2 => s1,
	_ => 0,
	};

	Self {
	lhs: Some(lhs),
	rhs,
	seen: HashSet::with_capacity(size),
	current: None,
	count_rows,
	count_cols,
	}
	}
	}

	impl<L, R> Iterator for UnionIter<L, R>
	where
	L: Iterator<Item = Entity>,
	R: Iterator<Item = Entity>,
	{
	type Item = Entity;

	fn next(&mut self) -> Option<Self::Item> {
	if let Some(iter) = self.current.as_mut() {
	for p in iter.by_ref() {
	if self.lhs.is_none() && self.seen.contains(&p) {
	continue;
	}

	let _ = self.seen.insert(p);
	return Some(Entity::Cell(p.0, p.1));
	}
	}

	if let Some(lhs) = self.lhs.as_mut() {
	for entity in lhs.by_ref() {
	let mut iter = entity.iter(self.count_rows, self.count_cols);
	if let Some(p) = iter.by_ref().next() {
	let _ = self.seen.insert(p);
	self.current = Some(iter);
	return Some(Entity::Cell(p.0, p.1));
	}
	}

	self.lhs = None;
	}

	for entity in self.rhs.by_ref() {
	let mut iter = entity.iter(self.count_rows, self.count_cols);

	for p in iter.by_ref() {
	if !self.seen.contains(&p) {
	let _ = self.seen.insert(p);
	self.current = Some(iter);
	return Some(Entity::Cell(p.0, p.1));
	}
	}
	}

	None
	}
	}

	/// An [`Iterator`] which goes over only cells which are present in first [`Object::Iter`] but not second.
	#[derive(Debug)]
	pub struct DiffIter<L> {
	lhs: L,
	seen: HashSet<(usize, usize)>,
	count_rows: usize,
	count_cols: usize,
	current: Option<EntityIterator>,
	}

	impl<L> DiffIter<L>
	where
	L: Iterator<Item = Entity>,
	{
	fn new<R>(lhs: L, rhs: R, count_rows: usize, count_cols: usize) -> Self
	where
	R: Iterator<Item = Entity>,
	{
	let size = match rhs.size_hint() {
	(s1, Some(s2)) if s1 == s2 => s1,
	_ => 0,
	};

	let mut seen = HashSet::with_capacity(size);
	for entity in rhs {
	seen.extend(entity.iter(count_rows, count_cols));
	}

	Self {
	lhs,
	seen,
	count_rows,
	count_cols,
	current: None,
	}
	}
	}

	impl<L> Iterator for DiffIter<L>
	where
	L: Iterator<Item = Entity>,
	{
	type Item = Entity;

	fn next(&mut self) -> Option<Self::Item> {
	if let Some(iter) = self.current.as_mut() {
	for p in iter.by_ref() {
	if !self.seen.contains(&p) {
	return Some(Entity::Cell(p.0, p.1));
	}
	}
	}

	for entity in self.lhs.by_ref() {
	let mut iter = entity.iter(self.count_rows, self.count_cols);

	for p in iter.by_ref() {
	if !self.seen.contains(&p) {
	self.current = Some(iter);
	return Some(Entity::Cell(p.0, p.1));
	}
	}
	}

	None
	}
	}

	/// An [`Iterator`] which goes goes over cells which are present in both [`Object::Iter`]ators.
	#[derive(Debug)]
	pub struct IntersectIter<L> {
	lhs: L,
	seen: HashSet<(usize, usize)>,
	count_rows: usize,
	count_cols: usize,
	current: Option<EntityIterator>,
	}

	impl<L> IntersectIter<L>
	where
	L: Iterator<Item = Entity>,
	{
	fn new<R>(lhs: L, rhs: R, count_rows: usize, count_cols: usize) -> Self
	where
	R: Iterator<Item = Entity>,
	{
	let size = match rhs.size_hint() {
	(s1, Some(s2)) if s1 == s2 => s1,
	_ => 0,
	};

	let mut seen = HashSet::with_capacity(size);
	for entity in rhs {
	seen.extend(entity.iter(count_rows, count_cols));
	}

	Self {
	lhs,
	seen,
	count_rows,
	count_cols,
	current: None,
	}
	}
	}

	impl<L> Iterator for IntersectIter<L>
	where
	L: Iterator<Item = Entity>,
	{
	type Item = Entity;

	fn next(&mut self) -> Option<Self::Item> {
	if let Some(iter) = self.current.as_mut() {
	for p in iter.by_ref() {
	if self.seen.contains(&p) {
	return Some(Entity::Cell(p.0, p.1));
	}
	}
	}

	for entity in self.lhs.by_ref() {
	let mut iter = entity.iter(self.count_rows, self.count_cols);

	for p in iter.by_ref() {
	if self.seen.contains(&p) {
	self.current = Some(iter);
	return Some(Entity::Cell(p.0, p.1));
	}
	}
	}

	None
	}
	}

	/// An [`Iterator`] which goes goes over cells which are not present an [`Object::Iter`]ator.
	#[derive(Debug)]
	pub struct InversionIter {
	all: SectorCellsIter,
	seen: HashSet<(usize, usize)>,
	}

	impl InversionIter {
	fn new<O>(obj: O, count_rows: usize, count_columns: usize) -> Self
	where
	O: Iterator<Item = Entity>,
	{
	let size = match obj.size_hint() {
	(s1, Some(s2)) if s1 == s2 => s1,
	_ => 0,
	};

	let mut seen = HashSet::with_capacity(size);
	for entity in obj {
	seen.extend(entity.iter(count_rows, count_columns));
	}

	let all = SectorCellsIter::new(0, count_rows, 0, count_columns);

	Self { all, seen }
	}
	}

	impl Iterator for InversionIter {
	type Item = Entity;

	fn next(&mut self) -> Option<Self::Item> {
	for p in self.all.by_ref() {
	if !self.seen.contains(&p) {
	return Some(Entity::Cell(p.0, p.1));
	}
	}

	None
	}
	}

	#[cfg(test)]
	mod tests {
	use crate::grid::records::vec_records::VecRecords;

	use super::*;

	#[test]
	fn cell_test() {
	assert_eq!(vec_cells((0, 0), 2, 3), [Entity::Cell(0, 0)]);
	assert_eq!(vec_cells((1, 1), 2, 3), [Entity::Cell(1, 1)]);
	assert_eq!(vec_cells((1, 1), 0, 0), [Entity::Cell(1, 1)]);
	assert_eq!(vec_cells((1, 100), 2, 3), [Entity::Cell(1, 100)]);
	assert_eq!(vec_cells((100, 1), 2, 3), [Entity::Cell(100, 1)]);
	}

	#[test]
	fn columns_test() {
	assert_eq!(
	vec_cells(Columns::new(..), 2, 3),
	[Entity::Column(0), Entity::Column(1), Entity::Column(2)]
	);
	assert_eq!(
	vec_cells(Columns::new(1..), 2, 3),
	[Entity::Column(1), Entity::Column(2)]
	);
	assert_eq!(vec_cells(Columns::new(2..), 2, 3), [Entity::Column(2)]);
	assert_eq!(vec_cells(Columns::new(3..), 2, 3), []);
	assert_eq!(vec_cells(Columns::new(3..), 0, 0), []);
	assert_eq!(vec_cells(Columns::new(0..1), 2, 3), [Entity::Column(0)]);
	assert_eq!(vec_cells(Columns::new(1..2), 2, 3), [Entity::Column(1)]);
	assert_eq!(vec_cells(Columns::new(2..3), 2, 3), [Entity::Column(2)]);
	assert_eq!(vec_cells(Columns::new(..), 0, 0), []);
	assert_eq!(vec_cells(Columns::new(..), 2, 0), []);
	assert_eq!(vec_cells(Columns::new(..), 0, 3), []);
	}

	#[test]
	fn first_column_test() {
	assert_eq!(vec_cells(Columns::first(), 5, 2), [Entity::Column(0)]);
	assert_eq!(vec_cells(Columns::first(), 0, 0), []);
	assert_eq!(vec_cells(Columns::first(), 10, 0), []);
	assert_eq!(vec_cells(Columns::first(), 0, 10), []);
	}

	#[test]
	fn last_column_test() {
	assert_eq!(vec_cells(Columns::last(), 5, 2), [Entity::Column(1)]);
	assert_eq!(vec_cells(Columns::last(), 5, 29), [Entity::Column(28)]);
	assert_eq!(vec_cells(Columns::last(), 0, 0), []);
	assert_eq!(vec_cells(Columns::last(), 10, 0), []);
	assert_eq!(vec_cells(Columns::last(), 0, 10), []);
	}

	#[test]
	fn last_column_sub_test() {
	assert_eq!(vec_cells(Columns::last(), 5, 2), [Entity::Column(1)]);
	assert_eq!(vec_cells(Columns::last() - 0, 5, 2), [Entity::Column(1)]);
	assert_eq!(vec_cells(Columns::last() - 1, 5, 2), [Entity::Column(0)]);
	assert_eq!(vec_cells(Columns::last() - 2, 5, 2), []);
	assert_eq!(vec_cells(Columns::last() - 100, 5, 2), []);
	}

	#[test]
	fn first_column_add_test() {
	assert_eq!(vec_cells(Columns::first(), 5, 2), [Entity::Column(0)]);
	assert_eq!(vec_cells(Columns::first() + 0, 5, 2), [Entity::Column(0)]);
	assert_eq!(vec_cells(Columns::first() + 1, 5, 2), [Entity::Column(1)]);
	assert_eq!(vec_cells(Columns::first() + 2, 5, 2), [Entity::Column(2)]);
	assert_eq!(
	vec_cells(Columns::first() + 100, 5, 2),
	[Entity::Column(100)]
	);
	}

	#[test]
	fn rows_test() {
	assert_eq!(
	vec_cells(Rows::new(..), 2, 3),
	[Entity::Row(0), Entity::Row(1)]
	);
	assert_eq!(vec_cells(Rows::new(1..), 2, 3), [Entity::Row(1)]);
	assert_eq!(vec_cells(Rows::new(2..), 2, 3), []);
	assert_eq!(vec_cells(Rows::new(2..), 0, 0), []);
	assert_eq!(vec_cells(Rows::new(0..1), 2, 3), [Entity::Row(0)],);
	assert_eq!(vec_cells(Rows::new(1..2), 2, 3), [Entity::Row(1)],);
	assert_eq!(vec_cells(Rows::new(..), 0, 0), []);
	assert_eq!(vec_cells(Rows::new(..), 0, 3), []);
	assert_eq!(
	vec_cells(Rows::new(..), 2, 0),
	[Entity::Row(0), Entity::Row(1)]
	);
	}

	#[test]
	fn last_row_test() {
	assert_eq!(vec_cells(Rows::last(), 5, 2), [Entity::Row(4)]);
	assert_eq!(vec_cells(Rows::last(), 100, 2), [Entity::Row(99)]);
	assert_eq!(vec_cells(Rows::last(), 0, 0), []);
	assert_eq!(vec_cells(Rows::last(), 5, 0), []);
	assert_eq!(vec_cells(Rows::last(), 0, 2), []);
	}

	#[test]
	fn first_row_test() {
	assert_eq!(vec_cells(Rows::first(), 5, 2), [Entity::Row(0)]);
	assert_eq!(vec_cells(Rows::first(), 100, 2), [Entity::Row(0)]);
	assert_eq!(vec_cells(Rows::first(), 0, 0), []);
	assert_eq!(vec_cells(Rows::first(), 5, 0), []);
	assert_eq!(vec_cells(Rows::first(), 0, 2), []);
	}

	#[test]
	fn last_row_sub_test() {
	assert_eq!(vec_cells(Rows::last(), 5, 2), [Entity::Row(4)]);
	assert_eq!(vec_cells(Rows::last() - 0, 5, 2), [Entity::Row(4)]);
	assert_eq!(vec_cells(Rows::last() - 1, 5, 2), [Entity::Row(3)]);
	assert_eq!(vec_cells(Rows::last() - 2, 5, 2), [Entity::Row(2)]);
	assert_eq!(vec_cells(Rows::last() - 3, 5, 2), [Entity::Row(1)]);
	assert_eq!(vec_cells(Rows::last() - 4, 5, 2), [Entity::Row(0)]);
	assert_eq!(vec_cells(Rows::last() - 5, 5, 2), []);
	assert_eq!(vec_cells(Rows::last() - 100, 5, 2), []);
	assert_eq!(vec_cells(Rows::last() - 1, 0, 0), []);
	assert_eq!(vec_cells(Rows::last() - 1, 5, 0), []);
	assert_eq!(vec_cells(Rows::last() - 1, 0, 2), []);
	}

	#[test]
	fn first_row_add_test() {
	assert_eq!(vec_cells(Rows::first(), 5, 2), [Entity::Row(0)]);
	assert_eq!(vec_cells(Rows::first() + 0, 5, 2), [Entity::Row(0)]);
	assert_eq!(vec_cells(Rows::first() + 1, 5, 2), [Entity::Row(1)]);
	assert_eq!(vec_cells(Rows::first() + 2, 5, 2), [Entity::Row(2)]);
	assert_eq!(vec_cells(Rows::first() + 3, 5, 2), [Entity::Row(3)]);
	assert_eq!(vec_cells(Rows::first() + 4, 5, 2), [Entity::Row(4)]);
	assert_eq!(vec_cells(Rows::first() + 5, 5, 2), [Entity::Row(5)]);
	assert_eq!(vec_cells(Rows::first() + 100, 5, 2), [Entity::Row(100)]);
	assert_eq!(vec_cells(Rows::first() + 1, 0, 0), [Entity::Row(1)]);
	assert_eq!(vec_cells(Rows::first() + 1, 5, 0), [Entity::Row(1)]);
	assert_eq!(vec_cells(Rows::first() + 1, 0, 2), [Entity::Row(1)]);
	}

	#[test]
	fn frame_test() {
	assert_eq!(
	vec_cells(Frame, 2, 3),
	[
	Entity::Cell(0, 0),
	Entity::Cell(0, 1),
	Entity::Cell(0, 2),
	Entity::Cell(1, 0),
	Entity::Cell(1, 1),
	Entity::Cell(1, 2)
	]
	);
	assert_eq!(vec_cells(Frame, 0, 0), []);
	assert_eq!(vec_cells(Frame, 2, 0), []);
	assert_eq!(vec_cells(Frame, 0, 2), []);
	}

	#[test]
	fn segment_test() {
	assert_eq!(
	vec_cells(Segment::new(.., ..), 2, 3),
	[
	Entity::Cell(0, 0),
	Entity::Cell(0, 1),
	Entity::Cell(0, 2),
	Entity::Cell(1, 0),
	Entity::Cell(1, 1),
	Entity::Cell(1, 2)
	]
	);
	assert_eq!(
	vec_cells(Segment::new(1.., ..), 2, 3),
	[Entity::Cell(1, 0), Entity::Cell(1, 1), Entity::Cell(1, 2)]
	);
	assert_eq!(vec_cells(Segment::new(2.., ..), 2, 3), []);

	assert_eq!(
	vec_cells(Segment::new(.., 1..), 2, 3),
	[
	Entity::Cell(0, 1),
	Entity::Cell(0, 2),
	Entity::Cell(1, 1),
	Entity::Cell(1, 2)
	]
	);
	assert_eq!(
	vec_cells(Segment::new(.., 2..), 2, 3),
	[Entity::Cell(0, 2), Entity::Cell(1, 2)]
	);
	assert_eq!(vec_cells(Segment::new(.., 3..), 2, 3), []);

	assert_eq!(
	vec_cells(Segment::new(1.., 1..), 2, 3),
	[Entity::Cell(1, 1), Entity::Cell(1, 2)]
	);
	assert_eq!(
	vec_cells(Segment::new(1..2, 1..2), 2, 3),
	[Entity::Cell(1, 1)]
	);

	assert_eq!(vec_cells(Segment::new(5.., 5..), 2, 3), []);
	}

	#[test]
	fn object_and_test() {
	assert_eq!(
	vec_cells(Cell::new(0, 0).and(Cell::new(0, 0)), 2, 3),
	[Entity::Cell(0, 0)]
	);
	assert_eq!(
	vec_cells(Cell::new(0, 0).and(Cell::new(1, 2)), 2, 3),
	[Entity::Cell(0, 0), Entity::Cell(1, 2)]
	);
	assert_eq!(vec_cells(Cell::new(0, 0).and(Cell::new(1, 2)), 0, 0), []);
	}

	#[test]
	fn object_not_test() {
	assert_eq!(vec_cells(Rows::first().not(Cell::new(0, 0)), 0, 0), []);
	assert_eq!(vec_cells(Cell::new(0, 0).not(Cell::new(0, 0)), 2, 3), []);
	assert_eq!(
	vec_cells(Rows::first().not(Cell::new(0, 0)), 2, 3),
	[Entity::Cell(0, 1), Entity::Cell(0, 2)]
	);
	assert_eq!(
	vec_cells(Columns::single(1).not(Rows::single(1)), 3, 3),
	[Entity::Cell(0, 1), Entity::Cell(2, 1)]
	);
	assert_eq!(
	vec_cells(Rows::single(1).not(Columns::single(1)), 3, 3),
	[Entity::Cell(1, 0), Entity::Cell(1, 2)]
	);
	}

	#[test]
	fn object_intersect_test() {
	assert_eq!(
	vec_cells(Rows::first().intersect(Cell::new(0, 0)), 0, 0),
	[]
	);
	assert_eq!(
	vec_cells(Segment::all().intersect(Rows::single(1)), 2, 3),
	[Entity::Cell(1, 0), Entity::Cell(1, 1), Entity::Cell(1, 2)]
	);
	assert_eq!(
	vec_cells(Cell::new(0, 0).intersect(Cell::new(0, 0)), 2, 3),
	[Entity::Cell(0, 0)]
	);
	assert_eq!(
	vec_cells(Rows::first().intersect(Cell::new(0, 0)), 2, 3),
	[Entity::Cell(0, 0)]
	);
	// maybe we somehow shall not limit the rows/columns by the max count?
	assert_eq!(
	vec_cells(Rows::single(1).intersect(Columns::single(1)), 2, 1),
	[]
	);
	}

	#[test]
	fn object_inverse_test() {
	assert_eq!(vec_cells(Segment::all().inverse(), 2, 3), []);
	assert_eq!(
	vec_cells(Cell::new(0, 0).inverse(), 2, 3),
	[
	Entity::Cell(0, 1),
	Entity::Cell(0, 2),
	Entity::Cell(1, 0),
	Entity::Cell(1, 1),
	Entity::Cell(1, 2)
	]
	);
	assert_eq!(
	vec_cells(Rows::first().inverse(), 2, 3),
	[Entity::Cell(1, 0), Entity::Cell(1, 1), Entity::Cell(1, 2)]
	);
	assert_eq!(vec_cells(Rows::first().inverse(), 0, 0), []);
	}

	fn vec_cells<O: Object<VecRecords<String>>>(
	o: O,
	count_rows: usize,
	count_cols: usize,
	) -> Vec<Entity> {
	let data = vec![vec![String::default(); count_cols]; count_rows];
	let records = VecRecords::new(data);
	o.cells(&records).collect::<Vec<_>>()
	}
	}