void test ( const CharT *s1, size_t pos1, size_t n1, const CharT  *s2, int expected ) {
    typedef std::experimental::basic_string_view<CharT> string_view_t;
    
    string_view_t sv1 ( s1 );
    string_view_t sv2 ( s2 );
    test1(sv1, pos1, n1, sv2, expected);
}
int main() {
  StrVec sv;
  print(sv);

  sv.push_back("s1"); print(sv);
  sv.push_back("s2"); print(sv);
  sv.push_back("s3"); print(sv);
  sv.push_back("s4"); print(sv);
  sv.push_back("s5"); print(sv);

  {
    StrVec sv2(sv); print(sv2);
    sv2.push_back("s6"); print(sv); print(sv2);
    sv.pop_back(); print(sv); print(sv2);
    sv = sv2; print(sv); print(sv2);
  }

  sv.reserve(sv.capacity() / 2); print(sv);
  sv.reserve(sv.capacity() * 2); print(sv);

  sv.resize(sv.size() + 2); print(sv);
  sv.resize(sv.size() + 2, "s7"); print(sv);
  sv.resize(sv.size() - 2); print(sv);
  sv.resize(sv.size() - 2, "s7"); print(sv);

  return 0;
}
void compare_test()
{
   const boost::string_view sv  = "52";
   boost::container::string s("0125925123");
   BOOST_TEST(s.compare(sv) < 0);
   BOOST_TEST(s.compare(boost::string_view("0125925123")) == 0);
   BOOST_TEST(s.compare(2u, s.size() - 2u, boost::string_view("25925123")) == 0);
   boost::string_view sv2("5212592512389");
   BOOST_TEST(s.compare(2u, s.size() - 2u, sv2, 3, sv2.size()-5u) == 0);
}
matrix2d<T> matrix2d<T>::appendCols(matrix2d<T> &m) {

  matrix2d<T> result(rows_, cols_ + m.cols_);

  std::size_t s1[] = {rows_,cols_}; // shape of left matrix
  std::size_t p1[] = {result.cols_,1}; // position of left matrix in result
  std::size_t s2[] = {m.rows_,m.cols_}; // shape of right matrix
  std::size_t p2[] = {result.cols_,1}; // position or right matrix in result

  std::valarray<std::size_t> sv1(s1, 2);
  std::valarray<std::size_t> pv1(p1, 2);
  std::valarray<std::size_t> sv2(s2, 2);
  std::valarray<std::size_t> pv2(p2, 2);

  result.data_[std::gslice(0, sv1, pv1)] = data_; // copy left matrix into place
  result.data_[std::gslice(cols_, sv2, pv2)] = m.data_; // repeat for m

  return result;
}
Esempio n. 5
0
int main()
{
	SinhVien sv1;
	sv1.Xuat();
	SinhVien sv2("0913084");
	sv2.Xuat();
	SinhVien sv3("0913084", "Le Hoang Anh Quoc");
	sv3.Xuat();
	SinhVien sv4("0913084", "Le Hoang Anh Quoc", 7, 8);
	sv4.Xuat();
	Ngay ngaySinh(1990, 4, 14);
	SinhVien sv5("0913084", "Le Hoang Anh Quoc", ngaySinh);
	sv5.Xuat();
	SinhVien sv6("0913084", "Le Hoang Anh Quoc", 1990, 4, 14, 9, 9.5);
	sv6.Xuat();
	SinhVien sv7(sv5);
	sv7.Xuat();
	system("pause");
	return 0;
}
Esempio n. 6
0
void test ( const CharT *s, size_t len ) {
    typedef std::experimental::basic_string_view<CharT> SV;
    {
    SV sv1 ( s );
    assert ( sv1.size() == len );
    assert ( sv1.data() == s );

    if ( len > 0 ) {
        sv1.remove_prefix ( 1 );
        assert ( sv1.size() == (len - 1));
        assert ( sv1.data() == (s + 1));
    }
    
    sv1.remove_prefix ( len - 1 );
    assert ( sv1.size() == 0 );

    SV sv2 ( s );
    sv2.remove_prefix ( len << 1 );
    assert ( sv1.size() == 0 ); 
    }
}
Esempio n. 7
0
sv2 sv2rotate(sv2 v, float a)
{
	cpVect cp = cpvrotate(cpv(v.x, v.y), -a*PI/180);
	return sv2(cp.x, cp.y);
}
static void
run_tests ()
{
  capacity_1::main ();
  cons_1::main ();
  cons_2::main ();
  cons_3::main ();
  element_access_1::main ();
  element_access_empty::main ();
  element_access_front_back::main ();
  inserters_2::main ();
  modifiers_remove_prefix::main ();
  modifiers_remove_suffix::main ();
  modifiers_swap::test01 ();
  operations_compare_1::main ();
  operations_compare_13650::main ();
  operations_copy_1::main ();
  operations_data_1::main ();
  operations_find_1::main ();
  operations_find_2::main ();
  operations_find_3::main ();
  operations_find_4::main ();
  operations_rfind_1::main ();
  operations_rfind_2::main ();
  operations_rfind_3::main ();
  operations_substr_1::main ();
  operators_2::main ();

  constexpr gdb::string_view sv_empty;
  SELF_CHECK (sv_empty.empty ());

  std::string std_string = "fika";
  gdb::string_view sv1 (std_string);
  SELF_CHECK (sv1 == "fika");

  constexpr const char *fika = "fika";
  gdb::string_view sv2 (fika);
  SELF_CHECK (sv2 == "fika");

  constexpr gdb::string_view sv3 (fika, 3);
  SELF_CHECK (sv3 == "fik");

  constexpr gdb::string_view sv4 (sv3);
  SELF_CHECK (sv4 == "fik");

  constexpr gdb::string_view::iterator it_begin = sv4.begin ();
  static_assert (*it_begin == 'f', "");

  constexpr gdb::string_view::iterator it_end = sv4.end ();
  static_assert (*it_end == 'a', "");

  const gdb::string_view::reverse_iterator it_rbegin = sv4.rbegin ();
  SELF_CHECK (*it_rbegin == 'k');

  const gdb::string_view::reverse_iterator it_rend = sv4.rend ();
  SELF_CHECK (*(it_rend - 1) == 'f');

  constexpr gdb::string_view::size_type size = sv4.size ();
  static_assert (size == 3, "");

  constexpr gdb::string_view::size_type length = sv4.length ();
  static_assert (length == 3, "");

  constexpr gdb::string_view::size_type max_size = sv4.max_size ();
  static_assert (max_size > 0, "");

  constexpr bool empty = sv4.empty ();
  static_assert (!empty, "");

  constexpr char c1 = sv4[1];
  static_assert (c1 == 'i', "");

  constexpr char c2 = sv4.at (2);
  static_assert (c2 == 'k', "");

  constexpr char front = sv4.front ();
  static_assert (front == 'f', "");

  constexpr char back = sv4.back ();
  static_assert (back == 'k', "");

  constexpr const char *data = sv4.data ();
  static_assert (data == fika, "");
}