int CGitHeadFileMap::GetHeadHash(const CString &gitdir, CGitHash &hash) { SHARED_TREE_PTR ptr; ptr = this->SafeGet(gitdir); if(ptr.get() == NULL) { SHARED_TREE_PTR ptr1(new CGitHeadFileList()); ptr1->ReadHeadHash(gitdir); hash = ptr1->m_Head; this->SafeSet(gitdir, ptr1); } else { if(ptr->CheckHeadUpdate()) { SHARED_TREE_PTR ptr1(new CGitHeadFileList()); ptr1->ReadHeadHash(gitdir); hash = ptr1->m_Head; this->SafeSet(gitdir, ptr1); } hash = ptr->m_Head; } return 0; }
void study_unique() { // shared std::shared_ptr<Base> ptr1(new Base(), delResource); { std::unique_ptr<Base, void(*)(Base*)> ptr1(new Base(), delResource); std::unique_ptr<Base> ptr2(new Base()); std::unique_ptr<Base> ptr3 = std::move(ptr2); std::cout << sizeof(ptr1) << "," << sizeof(ptr2) << std::endl; } std::cout << "unique_ptr" << std::endl; }
int main() { struct Complex (*ptr1)(int, int); ptr1 = make_Complex; struct Complex c = ptr1(2,5); struct Complex d = ptr1(3,6); struct Complex (*ptr2)(struct Complex, struct Complex); ptr2 = add; //print_Complex(ptr2(c, d)); struct Complex (*ptr[2])(int, int); ptr[0] = make_Complex; ptr[1] = make_Complex; print_Complex(ptr2(ptr[0](2,0), ptr[1](-2,0))); return 0; }
/** \brief function to test a ptr_t */ nunit_res_t ptr_testclass_t::ptr_counted(const nunit_testclass_ftor_t &testclass_ftor) throw() { // log to debug KLOG_DBG("enter"); // create a ptr_counted_t ptr_counted_t<const std::string> ptr1(nipmem_new std::string("hello world.")); // run some check on ptr1 NUNIT_ASSERT( ptr1.get_ptr() != NULL ); NUNIT_ASSERT( ptr1.count() == 1 ); NUNIT_ASSERT( *ptr1 == "hello world." ); // copy the ptr1 into ptr2 INSIDE bracket to ctor/dtor ptr2 { ptr_counted_t<const std::string> ptr2(ptr1); // run some check on ptr2 NUNIT_ASSERT( ptr2.get_ptr() == ptr1.get_ptr() ); NUNIT_ASSERT( ptr1.count() == 2 ); NUNIT_ASSERT( ptr2.count() == 2 ); NUNIT_ASSERT( *ptr2 == "hello world." ); } // now that ptr2 has been destructed, ptr1.count() MUST be 1 again NUNIT_ASSERT( ptr1.count() == 1 ); NUNIT_ASSERT( *ptr1 == "hello world." ); // return no error return NUNIT_RES_OK; }
void smart_ptr_tests::test_case_comparisions() { smart_ptr<char> ptr1(new char(45)); assert(ptr1 != nullptr); smart_ptr<char> ptr2(nullptr); assert(ptr2 == nullptr); smart_ptr<char> ptr3(nullptr); assert(ptr3 == nullptr); auto ptr4 = ptr1; assert(ptr4 == ptr1); ptr2 = ptr4; assert(ptr2 == ptr4 && ptr4 == ptr1); ptr3 = ptr1; assert(ptr3 == ptr1); *ptr1 = 123; assert(ptr3 == ptr1); ptr4 = nullptr; assert(ptr4 == nullptr); ptr3 = smart_ptr<char>(nullptr); assert(ptr3 == nullptr); assert(nullptr != ptr1); ptr1 = ptr2 = ptr3; assert(ptr1 == nullptr); assert(ptr2 == nullptr); assert(nullptr == ptr1); }
void smart_ptr_tests::test_case_copy_and_assignment() { smart_ptr<char> ptr1(new char(45)); assert(*ptr1 == 45); smart_ptr<char> ptr2(nullptr); smart_ptr<char> ptr3(nullptr); auto ptr4(ptr1); assert(*ptr4 == 45); ptr2 = ptr4; assert(*ptr2 == 45); ptr3 = ptr1; assert(*ptr3 == 45); *ptr1 = 123; assert(*ptr2 == 123); ptr3 = ptr1; assert(*ptr3 == 123); // nullptr is r-value so move operator= ptr4 = smart_ptr<char>(nullptr); ptr4 = nullptr; ptr3 = smart_ptr<char>(nullptr); ptr1 = ptr2 = ptr3; smart_ptr<const char> ptr5(new char(12)); ptr5 = ptr5 = ptr5; assert(*ptr5 == 12); }
void testObj::test<11>(void) { PointerWrapper<Data*> ptr(sp_); PointerWrapper<Data*> ptr1(ptr); PointerWrapper<const Data*> ptr2(ptr); }
void TestSharedPointers(void) { shared_ptr<CPrintable> ptr1(new CPrintable("1")); // create object 1 shared_ptr<CPrintable> ptr2(new CPrintable("2")); // create object 2 ptr1 = ptr2; // destroy object 1 ptr2 = shared_ptr<CPrintable>(new CPrintable("3")); // used as a return value ProcessObject(ptr1); // call a function CPrintable o1("bad"); //ptr1 = &o1; // Syntax error! It's on the stack.... // CPrintable *o2 = new CPrintable("bad2"); //ptr1 = o2; // Syntax error! Use the next line to do this... ptr1 = shared_ptr<CPrintable>(o2); // You can even use shared_ptr on ints! shared_ptr<int> a(new int); shared_ptr<int> b(new int); *a = 5; *b = 6; const int *q = a.get(); // use this for reading in multithreaded code // this is especially cool - you can also use it in lists. std::list< shared_ptr<int> > intList; std::list< shared_ptr<IPrintable> > printableList; for (int i = 0; i<100; ++i) { intList.push_back(shared_ptr<int>(new int(rand()))); printableList.push_back(shared_ptr<IPrintable>(new CPrintable("list"))); } }
void smart_ptr_tests::test_case_get() { smart_ptr<char> ptr1(new char(45)); assert(ptr1.get() != nullptr); smart_ptr<char> ptr2(nullptr); assert(ptr2.get() == nullptr); smart_ptr<char> ptr3(nullptr); assert(ptr3.get() == nullptr); auto ptr4(ptr1); assert(ptr4.get() == ptr1.get()); ptr2 = ptr4; assert(ptr2.get() == ptr4.get() && ptr4.get() == ptr1.get()); ptr3 = ptr1; assert(ptr3.get() == ptr1.get()); *ptr1 = 123; assert(ptr3.get() == ptr1.get()); ptr4 = nullptr; assert(ptr4.get() == nullptr); ptr3 = smart_ptr<char>(nullptr); assert(ptr3.get() == nullptr); ptr1 = ptr2 = ptr3; assert(ptr1.get() == nullptr); assert(ptr2.get() == nullptr); }
argument damp(EXTERNAL_ARG(ls1), EXTERNAL_ARG(ls2), EXTERNAL_ARG(fact)) { DECLARE_ARG(ls1, float_list *); DECLARE_ARG(ls2, float_list *); DECLARE_ARG(fact, float_val); float_list *ptr1((float_list*)ls1); float_list *ptr2((float_list*)ls2); float_list *nil(float_list::null_list()); if(float_list::is_null(ptr1) || float_list::is_null(ptr2)) { RETURN_ARG(nil); } stack_float_list vals; while(!float_list::is_null(ptr1) && !float_list::is_null(ptr2)) { const float_val h1(ptr1->get_head()); const float_val h2(ptr2->get_head()); const float_val c(std::log(fact * std::exp(h2) + (1.0 - fact) * std::exp(h1))); vals.push(c); ptr1 = ptr1->get_tail(); ptr2 = ptr2->get_tail(); } float_list *ptr(from_stack_to_list<stack_float_list,float_list>(vals)); RETURN_ARG(ptr); }
main() { MyClass t1; MyClass t2; MyDelegate ptr1( &t1, &MyClass::MyMethod ); MyDelegate ptr2( &t2, &MyClass::MyMethod ); int retval1, retval2; retval1 = ptr1( "apples" ); retval2 = ptr2( "cherries" ); printf( "Object 1 returned %d, object 2 returned %d\n", retval1, retval2 ); return 0; }
TEST(fxcrt, WeakPtrNonNull) { PseudoDeletable thing; EXPECT_EQ(0, thing.delete_count()); { UniquePtr unique(&thing); WeakPtr ptr1(std::move(unique)); EXPECT_TRUE(ptr1); EXPECT_EQ(&thing, ptr1.Get()); WeakPtr ptr2; EXPECT_FALSE(ptr1 == ptr2); EXPECT_TRUE(ptr1 != ptr2); { WeakPtr ptr3(ptr1); EXPECT_TRUE(ptr1 == ptr3); EXPECT_FALSE(ptr1 != ptr3); EXPECT_EQ(&thing, ptr3.Get()); { WeakPtr ptr4 = ptr1; EXPECT_TRUE(ptr1 == ptr4); EXPECT_FALSE(ptr1 != ptr4); EXPECT_EQ(&thing, ptr4.Get()); } } EXPECT_EQ(0, thing.delete_count()); } EXPECT_EQ(1, thing.delete_count()); }
/** This function is used for collated/folded string comparisons, {aByteSize1, aPtr1} - string 1, UTF16 encoded. aByteSize1 - length in bytes. {aByteSize2, aPtr2} - string 2, UTF16 encoded. aByteSize2 - length in bytes. aLevel - 0,1,2,3 - collation level; -1 - folded string comparison; The function returns negative, zero or positive if the first string is less than, equal to, or greater than the second string. @internalComponent */ static TInt Compare(TInt aLevel, TInt aByteSize1, const void* aPtr1, TInt aByteSize2, const void* aPtr2) { TPtrC16 ptr1(static_cast <const TUint16*> (aPtr1), (TUint)aByteSize1 /sizeof(TUint16)); TPtrC16 ptr2(static_cast <const TUint16*> (aPtr2), (TUint)aByteSize2 /sizeof(TUint16)); return aLevel >= 0 ? ptr1.CompareC(ptr2, aLevel, NULL) : ptr1.CompareF(ptr2); }
int main() { boost::intrusive_ptr<breeze::shared_proxy<A> > ptr1(new breeze::shared_proxy<A>()), ptr2, ptr3, ptr4; assert(1 == ptr1->use_count()); assert(ptr1->unique()); ptr2 = new breeze::shared_proxy<A>(); assert(1 == ptr2->use_count()); assert(ptr2->unique()); ptr2 = ptr2; assert(1 == ptr2->use_count()); assert(ptr2->unique()); ptr2 = boost::intrusive_ptr<breeze::shared_proxy<A> >(ptr1); ptr3 = ptr1; ptr4 = ptr1; assert(ptr1.get() == ptr2.get()); assert(ptr1.get() == ptr3.get()); assert(ptr1.get() == ptr4.get()); assert(4 == ptr1->use_count()); (**ptr1).function(); (*ptr1).get().function(); (*ptr1)->function(); (**ptr1.get()).function(); (*ptr1.get())->function(); (*ptr1.get()).get().function(); }
/** @SYMTestCaseID PDS-SQL-UT-4138 @SYMTestCaseDesc RFileBuf64 read test 1. The test performs file read operations using RFileBuf64 class. Tested "read" operations: - Zero max length request; - Too big read request; - Read beyond the end of the file; The purpose of the test: to verify the logic of RFileBuf64::Read(). @SYMTestActions RFileBuf64 read test 1. @SYMTestExpectedResults Test must not fail @SYMTestPriority High @SYMREQ REQ12106 REQ12109 */ void ReadTest1() { const TInt KBufMaxSize = 20;// This is half the file size RFileBuf64 fbuf(KBufMaxSize); TInt err = fbuf.Open(TheFs, KTestFile, EFileWrite | EFileRead | EFileShareReadersOrWriters); TEST2(err, KErrNone); fbuf.ProfilerReset(); //Zero max length request TUint8 buf1[1]; TPtr8 ptr1(buf1, 0); err = fbuf.Read(0, ptr1); TEST2(err, KErrNone); TEST2(fbuf.iFileReadCount, 0); TEST2(fbuf.iFileReadAmount, 0); TEST2(fbuf.iFileSizeCount, 0); //Too big request TBuf8<KBufMaxSize * 2> buf2; err = fbuf.Read(0, buf2); TEST2(err, KErrNone); TEST2(fbuf.iFileReadCount, 1); TEST2(fbuf.iFileReadAmount, (KBufMaxSize * 2)); TEST2(fbuf.iFileSizeCount, 1); VerifyFileContent(buf2); //Read beyond the end of the file err = fbuf.Read(2000, buf2); TEST2(err, KErrNone); TEST2(buf2.Length(), 0); //Write "5678" in the buffer, pos [4..8) err = fbuf.Write(4, _L8("5678")); TEST2(err, KErrNone); //Too big request. There are pending data in the buffer. TBuf8<KBufMaxSize + 2> buf3; err = fbuf.Read(1, buf3); TEST2(err, KErrNone); VerifyFileContent(buf3, 1); //Read from a non-zero file position to move the buffer start pos. The cached file pos will be 35 at the end. TBuf8<5> buf4; err = fbuf.Read(30, buf4); TEST2(err, KErrNone); VerifyFileContent(buf4, 30); err = fbuf.Read(35, buf4); TEST2(err, KErrNone); VerifyFileContent(buf4, 35); //Too big request. No pending data in the buffer. The file read pos is before the position of the cached data in the buffer. err = fbuf.Read(10, buf3); TEST2(err, KErrNone); VerifyFileContent(buf3, 10); fbuf.Close(); }
int main () { int num = 10; SmartPointer<int> ptr1(&num); SmartPointer<int> ptr2(ptr1); SmartPointer<int> ptr3 = ptr2; std::cout << num << std::endl; std::cout << ptr1 << std::endl; return 0; }
/** Returns true if the contents of aBmp1 match the contents of aBmp2 */ TBool CTestContainer::CompareBitmapsL(CFbsBitmap* aBmp1, CFbsBitmap* aBmp2) { if (aBmp1 == NULL || aBmp2 == NULL) { return EFalse; } TInt width = aBmp1->SizeInPixels().iWidth; TInt height = aBmp1->SizeInPixels().iHeight; if (aBmp1->DisplayMode() == aBmp2->DisplayMode()) { TInt lineLen = CFbsBitmap::ScanLineLength(width,aBmp1->DisplayMode()); HBufC8* buf1 = HBufC8::NewMaxLC(lineLen); HBufC8* buf2 = HBufC8::NewMaxLC(lineLen); TPtr8 ptr1(buf1->Des()); TPtr8 ptr2(buf2->Des()); TInt row = 0; for (row = 0; row < height; ++row) { aBmp1->GetScanLine(ptr1,TPoint(0,row),width,aBmp1->DisplayMode()); aBmp2->GetScanLine(ptr2,TPoint(0,row),width,aBmp2->DisplayMode()); if (ptr1!=ptr2) { CleanupStack::PopAndDestroy(buf2); CleanupStack::PopAndDestroy(buf1); return EFalse; } } CleanupStack::PopAndDestroy(buf2); CleanupStack::PopAndDestroy(buf1); } else { TRgb p1(0,0,0); TRgb p2(0,0,0); TInt i = 0; for(i = 0; i < width; i++) { TInt j = 0; for(j = 0; j < height; j++) { aBmp1->GetPixel(p1, TPoint(i, j)); aBmp2->GetPixel(p2, TPoint(i, j)); if(p1 != p2) { return EFalse; } } } } return ETrue; }
void testObj::test<10>(void) { PointerWrapper< boost::shared_ptr<Data> > ptr(sp_); PointerWrapper< boost::shared_ptr<Data> > ptr1(ptr); PointerWrapper< boost::shared_ptr<const Data> > ptr2(ptr); PointerWrapper<Data*> ptr3(ptr); PointerWrapper<const Data*> ptr4(ptr); }
EXPORT_C TInt RMobileCall::GetMobileCallStatus(TMobileCallStatus& aStatus) const /** * This method returns the current status of a mobile call * * \retval aStatus Will contain the retrieved call state * \return KErrNone */ { TPckg<TMobileCallStatus> ptr1(aStatus); return Get(EMobileCallGetMobileCallStatus, ptr1); }
EXPORT_C TInt RMobileCall::GetUUSCaps(TUint32& aCaps) const /** * This method returns the current instance of the User-User Signalling capabilities of the call * * \retval aCaps An integer that will contain the bit-wise sum of the UUS capabilities * \return KErrNone * \exception KErrNotSupported if UUS functionality is not supported by the phone/TSY */ { TPckg<TUint32> ptr1(aCaps); return Get(EMobileCallGetUUSCaps, ptr1); }
int main(int argc, char **argv) { HasPtr ptr1("good"); HasPtr ptr2 = ptr1; HasPtr ptr3("terrible"); std::string* str2 = new std::string("happy"); ptr2.setPs(str2); ptr1 = ptr3; ptr1.print(); ptr2.print(); return 0; }
EXPORT_C TInt RMobileCall::SetPrivacy(RMobilePhone::TMobilePhonePrivacy aPrivacySetting) const /** * This method sets a new value for the privacy setting of a mobile call * It will complete after the phone has requested the new setting * * \param aPrivacySetting Wanted privacy setting (either on or off) * \return KErrNone if request processed successfully * \exception KErrMMEtelWrongMode if request made during a mode that does not support it */ { TPckg<RMobilePhone::TMobilePhonePrivacy> ptr1(aPrivacySetting); return Set(EMobileCallSetPrivacy, ptr1); }
EXPORT_C TInt RMobileCall::SetTrafficChannel(TMobileCallTch aTchRequest) const /** * This method sets a new value for the traffic channel setting of a mobile call * It will complete after the phone has requested the new setting * * \param aTchRequest Wanted traffic channel (either analog or digital) * \return KErrNone if request processed successfully * \exception KErrMMEtelWrongMode if request made during a mode that does not support it */ { TPckg<TMobileCallTch> ptr1(aTchRequest); return Set(EMobileCallSetTrafficChannel,ptr1); }
void testObj::test<9>(void) { PointerWrapper< Commons::SharedPtrNotNULL<Data> > ptr(spnn_); PointerWrapper< Commons::SharedPtrNotNULL<Data> > ptr1(ptr); PointerWrapper< Commons::SharedPtrNotNULL<const Data> > ptr2(ptr); PointerWrapper< boost::shared_ptr<Data> > ptr3(ptr); PointerWrapper< boost::shared_ptr<const Data> > ptr4(ptr); PointerWrapper<Data*> ptr5(ptr); PointerWrapper<const Data*> ptr6(ptr); }
TEST(fxcrt, RetainPtrMoveCtor) { PseudoRetainable obj; { CFX_RetainPtr<PseudoRetainable> ptr1(&obj); { CFX_RetainPtr<PseudoRetainable> ptr2(std::move(ptr1)); EXPECT_EQ(1, obj.retain_count()); EXPECT_EQ(0, obj.release_count()); } EXPECT_EQ(1, obj.retain_count()); EXPECT_EQ(1, obj.release_count()); } EXPECT_EQ(1, obj.retain_count()); EXPECT_EQ(1, obj.release_count()); }
TEST(fxcrt, RetainPtrCopyCtor) { PseudoRetainable obj; { CFX_RetainPtr<PseudoRetainable> ptr1(&obj); { CFX_RetainPtr<PseudoRetainable> ptr2(ptr1); EXPECT_EQ(2, obj.retain_count()); EXPECT_EQ(0, obj.release_count()); } EXPECT_EQ(2, obj.retain_count()); EXPECT_EQ(1, obj.release_count()); } EXPECT_EQ(2, obj.retain_count()); EXPECT_EQ(2, obj.release_count()); }
TEST(fxcrt, WeakPtrCyclic) { PseudoDeletable thing1; PseudoDeletable thing2; { UniquePtr unique1(&thing1); UniquePtr unique2(&thing2); WeakPtr ptr1(std::move(unique1)); WeakPtr ptr2(std::move(unique2)); ptr1->SetNext(ptr2); ptr2->SetNext(ptr1); } // Leaks without explicit clear. EXPECT_EQ(0, thing1.delete_count()); EXPECT_EQ(0, thing2.delete_count()); }
void smart_ptr_tests::test_case_use_count() { smart_ptr<char> ptr1(new char(45)); assert(ptr1.use_count() == 1); smart_ptr<char> ptr2(nullptr); smart_ptr<char> ptr3(nullptr); auto ptr4(ptr1); assert(ptr4.use_count() == 2); assert(ptr3.use_count() == 0); assert(ptr2.use_count() == 0); assert(ptr1.use_count() == 2); ptr2 = ptr4; assert(ptr4.use_count() == 3); assert(ptr3.use_count() == 0); assert(ptr2.use_count() == 3); assert(ptr1.use_count() == 3); ptr3 = ptr1; assert(ptr3.use_count() == 4); assert(ptr4.use_count() == 4); assert(ptr2.use_count() == 4); assert(ptr1.use_count() == 4); *ptr1 = 123; assert(ptr3.use_count() == 4); assert(ptr4.use_count() == 4); assert(ptr2.use_count() == 4); assert(ptr1.use_count() == 4); // testing overloading for nullptr ptr4 = nullptr; assert(ptr4.use_count() == 0); assert(ptr3.use_count() == 3); assert(ptr2.use_count() == 3); assert(ptr1.use_count() == 3); // NULL is r-value so move operator= ptr3 = smart_ptr<char>(nullptr); assert(ptr4.use_count() == 0); assert(ptr3.use_count() == 0); assert(ptr2.use_count() == 2); assert(ptr1.use_count() == 2); ptr1 = ptr2 = ptr3; assert(ptr4.use_count() == 0); assert(ptr3.use_count() == 0); assert(ptr2.use_count() == 0); assert(ptr1.use_count() == 0); }
TEST(fxcrt, WeakPtrCyclicClear) { PseudoDeletable thing1; PseudoDeletable thing2; { UniquePtr unique1(&thing1); UniquePtr unique2(&thing2); WeakPtr ptr1(std::move(unique1)); WeakPtr ptr2(std::move(unique2)); ptr1->SetNext(ptr2); ptr2->SetNext(ptr1); ptr1.Clear(); EXPECT_EQ(1, thing1.delete_count()); EXPECT_EQ(0, thing2.delete_count()); } EXPECT_EQ(1, thing1.delete_count()); EXPECT_EQ(1, thing2.delete_count()); }
TEST(fxcrt, WeakPtrResetNull) { PseudoDeletable thing; { UniquePtr unique(&thing); WeakPtr ptr1(std::move(unique)); WeakPtr ptr2 = ptr1; ptr1.Reset(); EXPECT_FALSE(ptr1); EXPECT_EQ(nullptr, ptr1.Get()); EXPECT_TRUE(ptr2); EXPECT_EQ(&thing, ptr2.Get()); EXPECT_FALSE(ptr1 == ptr2); EXPECT_TRUE(ptr1 != ptr2); EXPECT_EQ(0, thing.delete_count()); } EXPECT_EQ(1, thing.delete_count()); }