From 37fd7b9c3be736d4bc0d88785004e1185b2e1536 Mon Sep 17 00:00:00 2001 From: Louis Gerbarg Date: Wed, 3 Nov 2010 17:10:26 -0700 Subject: [PATCH 1/9] Added contributor agreement link to README --- README.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 63efe65..60bf2dd 100644 --- a/README.md +++ b/README.md @@ -12,4 +12,5 @@ __Usage__ You probably don't want to use this yet unless you are intending to hack on it. It's API is similiar to CoreData, though there is no modeler (it derives object info directly from LGGOObjects). The only header files that should be considered public to framework clients are LGGOGraph.h and LGGOGraphContext.h, and even those currently leak some private details. -Mailing List: [http://groups.google.com/group/graphobjects](http://groups.google.com/group/graphobjects) \ No newline at end of file +Mailing List: [http://groups.google.com/group/graphobjects](http://groups.google.com/group/graphobjects) +Contributor Agreement: [https://github.com/GLsoft/GraphObjects/raw/master/GCA.pdf](https://github.com/GLsoft/GraphObjects/raw/master/GCA.pdf) From fa7050feec4afc07aa5518628136342fefe194eb Mon Sep 17 00:00:00 2001 From: Louis Gerbarg Date: Thu, 4 Nov 2010 09:13:09 -0700 Subject: [PATCH 2/9] Fixed some mistakes in the README --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 60bf2dd..74fadfd 100644 --- a/README.md +++ b/README.md @@ -6,7 +6,7 @@ GraphObjects is intended to work on Mac OS X 10.6+ and iOS 4.2+. The underlying __Building__ -GraphObjects requires a clang 2.0 toolchain in order to build. that mean that no currently released build of Xcode can build it out of box. In order to build it you either need to build a a custome MacOS X 10.6 or iOS 4.2 SDK a copy of clang pulled from their repository, hack up your system compilers, or use unreleased developer tool previews. While GraphObjects has occasionally been built for iOS, it currently is being primarily brought up on Mac OS X x86. +GraphObjects requires a clang 2.0 toolchain in order to build. that mean that no currently released build of Xcode can build it out of box. In order to build it you either need to build a a custom MacOS X 10.6 or iOS 4.2 SDK using a copy of clang pulled from their repository, hack up your system compilers, or use unreleased developer tool previews. While GraphObjects has occasionally been built for iOS, it currently is being primarily brought up on Mac OS X x86. __Usage__ From b6389472c6651703d69283f6785ccf76a489c323 Mon Sep 17 00:00:00 2001 From: Louis Gerbarg Date: Thu, 4 Nov 2010 09:26:27 -0700 Subject: [PATCH 3/9] First cut of new smart pointer implementation Solves retain cycles between Objective C and C++ Incomplete, still leaking C++ objects due to a bug in the ObjC bridge (but it is a non-cyclic leak) Implements object uniquing for numbers and strings --- GraphObjects.xcodeproj/project.pbxproj | 4 + Source/Storage/LGGOCXXMemoryDescriptor.cpp | 2 +- Source/Storage/LGGOCXXMemoryDescriptor.h | 4 +- Source/Storage/LGGOCXXStoreContext.cpp | 86 ++--- Source/Storage/LGGOCXXStoreContext.h | 19 +- Source/Storage/LGGOCXXStoreSegment.cpp | 23 +- Source/Storage/LGGOCXXStoreSegment.h | 14 +- .../HackArray/LGGOCXXHackArray.cpp | 45 +-- .../Collections/HackArray/LGGOCXXHackArray.h | 15 +- Source/Types/LGGOCXXClass.cpp | 18 +- Source/Types/LGGOCXXClass.h | 8 +- Source/Types/LGGOCXXNumber.cpp | 50 ++- Source/Types/LGGOCXXNumber.h | 6 +- Source/Types/LGGOCXXString.cpp | 32 +- Source/Types/LGGOCXXString.h | 6 +- Source/Types/LGGOCXXType.cpp | 20 +- Source/Types/LGGOCXXType.h | 12 +- Source/Utilities/LGGOCXXAddress.cpp | 309 ++++++++++++++++++ Source/Utilities/LGGOCXXAddress.h | 95 +++++- Source/objc/LGGOClass.h | 3 +- Source/objc/LGGOClass.mm | 26 +- Source/objc/LGGOGraphContext.h | 5 +- Source/objc/LGGOGraphContext.mm | 45 +-- Source/objc/LGGOMutableArray.h | 3 +- Source/objc/LGGOMutableArray.mm | 55 ++-- Source/objc/LGGONumber.h | 2 +- Source/objc/LGGONumber.mm | 67 ++-- Source/objc/LGGOString.h | 2 +- Source/objc/LGGOString.mm | 60 +++- Tests/LGGOArrayTests.m | 7 +- Tests/LGGOCXXStoreContextTests.mm | 28 ++ Tests/LGGOCXXStoreSegmentTests.mm | 3 + 32 files changed, 765 insertions(+), 309 deletions(-) create mode 100644 Source/Utilities/LGGOCXXAddress.cpp diff --git a/GraphObjects.xcodeproj/project.pbxproj b/GraphObjects.xcodeproj/project.pbxproj index e51d295..09f2b81 100644 --- a/GraphObjects.xcodeproj/project.pbxproj +++ b/GraphObjects.xcodeproj/project.pbxproj @@ -37,6 +37,7 @@ BF532C2212796F240040B280 /* LGGOGraph.h in Headers */ = {isa = PBXBuildFile; fileRef = BF532C2012796F240040B280 /* LGGOGraph.h */; }; BF532C2312796F240040B280 /* LGGOGraph.mm in Sources */ = {isa = PBXBuildFile; fileRef = BF532C2112796F240040B280 /* LGGOGraph.mm */; }; BF6637F212765349000B4A8D /* GraphObjects.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = BF33553F1276519600F34934 /* GraphObjects.framework */; }; + BF7C08AA12832CC100BFD1DB /* LGGOCXXAddress.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BF7C08A912832CC100BFD1DB /* LGGOCXXAddress.cpp */; }; BFA13448127653DA00D13611 /* LGGOArrayTests.m in Sources */ = {isa = PBXBuildFile; fileRef = BFA1343F127653DA00D13611 /* LGGOArrayTests.m */; }; BFA13449127653DA00D13611 /* LGGOGraphTests.m in Sources */ = {isa = PBXBuildFile; fileRef = BFA13441127653DA00D13611 /* LGGOGraphTests.m */; }; BFA1344A127653DA00D13611 /* LGGOCXXStoreSegmentTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = BFA13443127653DA00D13611 /* LGGOCXXStoreSegmentTests.mm */; }; @@ -97,6 +98,7 @@ BF532C2112796F240040B280 /* LGGOGraph.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = LGGOGraph.mm; sourceTree = ""; }; BF6637E91276532E000B4A8D /* GraphObjectsTests.octest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = GraphObjectsTests.octest; sourceTree = BUILT_PRODUCTS_DIR; }; BF6637EA1276532E000B4A8D /* GraphObjectsTests-Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = "GraphObjectsTests-Info.plist"; sourceTree = ""; }; + BF7C08A912832CC100BFD1DB /* LGGOCXXAddress.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LGGOCXXAddress.cpp; sourceTree = ""; }; BFA1343E127653DA00D13611 /* LGGOArrayTests.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LGGOArrayTests.h; sourceTree = ""; }; BFA1343F127653DA00D13611 /* LGGOArrayTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = LGGOArrayTests.m; sourceTree = ""; }; BFA13440127653DA00D13611 /* LGGOGraphTests.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LGGOGraphTests.h; sourceTree = ""; }; @@ -277,6 +279,7 @@ children = ( BFD68E4C1278C4DC004CBBD2 /* unicode */, BF3355761276523900F34934 /* LGGOCXXAddress.h */, + BF7C08A912832CC100BFD1DB /* LGGOCXXAddress.cpp */, BF3355771276523900F34934 /* LGGOByteOrder.h */, ); path = Utilities; @@ -456,6 +459,7 @@ BFA37A1D1280D5CC002A0892 /* LGGOCXXHackArray.cpp in Sources */, BFA37A211280D930002A0892 /* LGGOMutableArray.mm in Sources */, BFA37A241280DC59002A0892 /* LGGOCXXObject.cpp in Sources */, + BF7C08AA12832CC100BFD1DB /* LGGOCXXAddress.cpp in Sources */, ); runOnlyForDeploymentPostprocessing = 0; }; diff --git a/Source/Storage/LGGOCXXMemoryDescriptor.cpp b/Source/Storage/LGGOCXXMemoryDescriptor.cpp index 802b0b6..497b76e 100644 --- a/Source/Storage/LGGOCXXMemoryDescriptor.cpp +++ b/Source/Storage/LGGOCXXMemoryDescriptor.cpp @@ -217,7 +217,7 @@ const uint64_t LGGOCXXMappedMemoryDescriptor::getSize (void) { return 0; } -LGGOCXXTaggedMemoryDescriptor::LGGOCXXTaggedMemoryDescriptor(LGGOCXXAddress A) : address(A) { } +LGGOCXXTaggedMemoryDescriptor::LGGOCXXTaggedMemoryDescriptor(uint64_t A) : address(A) { } void *LGGOCXXTaggedMemoryDescriptor::getData (void) { return static_cast(&address); diff --git a/Source/Storage/LGGOCXXMemoryDescriptor.h b/Source/Storage/LGGOCXXMemoryDescriptor.h index 4ecdb49..7297be3 100644 --- a/Source/Storage/LGGOCXXMemoryDescriptor.h +++ b/Source/Storage/LGGOCXXMemoryDescriptor.h @@ -109,9 +109,9 @@ class LGGOCXXMappedMemoryDescriptor : public LGGOCXXCoreMemoryDescriptor { class LGGOCXXTaggedMemoryDescriptor : public LGGOCXXCoreMemoryDescriptor { private: - LGGOCXXAddress address; + uint64_t address; public: - explicit LGGOCXXTaggedMemoryDescriptor(LGGOCXXAddress A); + explicit LGGOCXXTaggedMemoryDescriptor(uint64_t A); virtual void *getData (void); virtual const uint64_t getSize (void); diff --git a/Source/Storage/LGGOCXXStoreContext.cpp b/Source/Storage/LGGOCXXStoreContext.cpp index e3e8233..f38ead9 100644 --- a/Source/Storage/LGGOCXXStoreContext.cpp +++ b/Source/Storage/LGGOCXXStoreContext.cpp @@ -35,11 +35,10 @@ LGGOCXXStoreContext::LGGOCXXStoreContext(const LGGOCXXSharedStore &S) : store(S), nextAddressValue(256), nativeRetainFunc(NULL), nativeReleaseFunc(NULL) { - writableSegment = new LGGOCXXWritableStoreSegment; } -LGGOCXXAddress LGGOCXXStoreContext::getNextFreeAddress (void) { - LGGOCXXAddress retval = LGGOCXXAddress(nextAddressValue<<4); +uint64_t LGGOCXXStoreContext::getNextFreeAddress (void) { + uint64_t retval = nextAddressValue<<4; nextAddressValue++; return retval; } @@ -67,77 +66,78 @@ void LGGOCXXStoreContext::nativeObjectRelease(void *nativeObject) { //FIXME implement transient save here void LGGOCXXStoreContext::writeSegment (void) { +#if 0 std::ostringstream path; - int fd = open(store->getStorePath().c_str(), O_WRONLY | O_CREAT); - LGGOCXXSharedMemoryDescriptor descriptor = writableSegment->serializeToMemory(); + LGGOCXXWritableStoreSegment writableSegment; + + int fd = open(store->getStorePath().c_str(), O_WRONLY | O_CREAT);/ LGGOCXXSharedMemoryDescriptor descriptor = writableSegment.serializeToMemory(); path << store->getStorePath() << "/" << descriptor->getHash()->getHexValue(); if (fd > 0) { write(fd, descriptor->getData(), descriptor->getSize()); - delete writableSegment; - writableSegment = new LGGOCXXWritableStoreSegment; LGGOCXXSharedMemoryDescriptor newDescriptor = LGGOCXXSharedMemoryDescriptor(new LGGOCXXMappedMemoryDescriptor(path.str())); LGGOCXXSharedStoreSegment newSegment = LGGOCXXSharedStoreSegment(new LGGOCXXStoreSegment(newDescriptor)); segments.push_back(newSegment); } else { assert(0); } +#endif + assert(0); } void LGGOCXXStoreContext::commit (void) { //FIXME we need to use a locking protocol here } -void LGGOCXXStoreContext::setResolvedObjectForAddress(const LGGOCXXSharedType &object, LGGOCXXAddress address) { - //resolvedObjects[address] = LGGOCXXWeakType(object); - resolvedObjects[address] = object; +LGGOCXXSharedType LGGOCXXStoreContext::rootObject(void) { + LGGOCXXSharedAddress address(getAddress(1<<4)); + return *address; } -LGGOCXXSharedType LGGOCXXStoreContext::resolvedObjectForAddress(LGGOCXXAddress address) { - LGGOCXXSharedType retval; - - std::map::iterator i; - i = resolvedObjects.find(address); +void LGGOCXXStoreContext::setRootObject(const LGGOCXXSharedType &object) { + LGGOCXXSharedAddress address(shared_from_this(), 1<<4); + address.setType(object); +} - if (i != resolvedObjects.end()) { - retval = i->second; - } +LGGOCXXSharedAddress LGGOCXXStoreContext::getAddress (uint64_t address) { + std::map::iterator i = addresses.find(address); - return retval; -} + if (i == addresses.end()) { + return LGGOCXXSharedAddress(i->second); + } else { + assert(0); + LGGOCXXSharedAddress retval = LGGOCXXSharedAddress(shared_from_this(), address); + setAddressForAddressValue(LGGOCXXWeakAddress(retval), address); + return retval; + } +}; -LGGOCXXSharedType LGGOCXXStoreContext::rootObject(void) { - return getObjectForAddress(LGGOCXXAddress(1<<4)); +void LGGOCXXStoreContext::setAddressForAddressValue(const LGGOCXXWeakAddress& address, uint64_t addressValue) { +// addresses[addressValue] = address; + addresses.insert(std::pair(addressValue, address)); } -void LGGOCXXStoreContext::setRootObject(const LGGOCXXSharedType &object) { - setResolvedObjectForAddress(object, LGGOCXXAddress(1<<4)); - setObjectForAddress(object, LGGOCXXAddress(1<<4)); -} +LGGOCXXSharedAddress LGGOCXXStoreContext::getAddressForAddressValue(uint64_t addressValue) { + std::map::iterator i = addresses.find(addressValue); -void LGGOCXXStoreContext::setObjectForAddress(const LGGOCXXSharedType &object, LGGOCXXAddress address) { - //FIXME this could be deferred - writableSegment->setDescriptorForAddress(object->getSerializedData(), address); + if (i != addresses.end()) { + return LGGOCXXSharedAddress(i->second); + } + + return LGGOCXXSharedAddress(); } -LGGOCXXSharedType LGGOCXXStoreContext::getObjectForAddress (LGGOCXXAddress address) { - LGGOCXXSharedType retval = resolvedObjectForAddress(address); - - if (retval.get() == NULL) { - LGGOCXXSharedMemoryDescriptor descriptor = writableSegment->getDescriptorForAddress(address); +LGGOCXXSharedMemoryDescriptor LGGOCXXStoreContext::getDescriptorForAddress (uint64_t address) { + LGGOCXXSharedMemoryDescriptor retval; - if (descriptor.get() == NULL) { + std::vector::iterator i; + for (i = segments.begin(); i != segments.end(); ++i) { + retval = (*i)->getDescriptorForAddress(address); - std::vector::iterator i; - for (i = segments.begin(); i != segments.end(); ++i) { - descriptor = writableSegment->getDescriptorForAddress(address); - - if (descriptor.get() != NULL) { - break; - } - } + if (retval.get() != NULL) { + break; } } diff --git a/Source/Storage/LGGOCXXStoreContext.h b/Source/Storage/LGGOCXXStoreContext.h index 9ea1c77..4220fdb 100644 --- a/Source/Storage/LGGOCXXStoreContext.h +++ b/Source/Storage/LGGOCXXStoreContext.h @@ -34,7 +34,9 @@ typedef std::tr1::weak_ptr LGGOCXXWeakStoreContext; #define LGGOCXXSTORECONTEXT_H #include +#include +#include "LGGOCXXMemoryDescriptor.h" #include "LGGOCXXStore.h" #include "LGGOCXXStoreSegment.h" #include "LGGOCXXType.h" @@ -45,24 +47,20 @@ class LGGOCXXWritableStoreSegment; class LGGOCXXStoreContext : public std::tr1::enable_shared_from_this { private: LGGOCXXSharedStore store; - LGGOCXXWritableStoreSegment *writableSegment; +// LGGOCXXWritableStoreSegment *writableSegment; std::vector segments; uint64_t nextAddressValue; void (*nativeReleaseFunc)(void *); void (*nativeRetainFunc)(void *); + std::map addresses; //FIXME this should be weak, but without native types that can bump shared_ptrs it needs to be strong for now - std::map resolvedObjects; public: explicit LGGOCXXStoreContext(const LGGOCXXSharedStore &S); - LGGOCXXAddress getNextFreeAddress (void); + uint64_t getNextFreeAddress (void); void writeSegment (void); void commit (void); - void setResolvedObjectForAddress(const LGGOCXXSharedType &object, LGGOCXXAddress address); - LGGOCXXSharedType resolvedObjectForAddress(LGGOCXXAddress address); - - LGGOCXXSharedType getObjectForAddress (LGGOCXXAddress address); - void setObjectForAddress(const LGGOCXXSharedType &object, LGGOCXXAddress address); + LGGOCXXSharedType rootObject(void); void setRootObject(const LGGOCXXSharedType &object); @@ -72,6 +70,11 @@ class LGGOCXXStoreContext : public std::tr1::enable_shared_from_thisgetData(); @@ -70,7 +70,7 @@ LGGOCXXSharedMemoryDescriptor LGGOCXXStoreSegment::getDescriptorForAddress (LGGO uint64_t i; for (i = 0; i < pointerCount; ++i) { - if (LGGOCXXAddress(pointerTablePointers[i]) == address) { + if (pointerTablePointers[i] == address) { break; } } @@ -100,12 +100,12 @@ LGGOCXXSharedMemoryDescriptor LGGOCXXStoreSegment::getDescriptorForAddress (LGGO return retval; } - -void LGGOCXXWritableStoreSegment::setDescriptorForAddress(const LGGOCXXSharedMemoryDescriptor &object, LGGOCXXAddress address) { +#if 0 +void LGGOCXXWritableStoreSegment::setDescriptorForAddress(const LGGOCXXSharedMemoryDescriptor &object, uint64_t address) { memoryObjects[address] = object; } -LGGOCXXSharedMemoryDescriptor LGGOCXXWritableStoreSegment::getDescriptorForAddress (LGGOCXXAddress address) { +LGGOCXXSharedMemoryDescriptor LGGOCXXWritableStoreSegment::getDescriptorForAddress (uint64_t address) { LGGOCXXSharedMemoryDescriptor retval; std::map::iterator i = memoryObjects.find(address); @@ -126,7 +126,7 @@ LGGOCXXSharedMemoryDescriptor LGGOCXXWritableStoreSegment::serializeToMemory(voi uint64_t k; uint64_t pointerCount = memoryObjects.size(); - uint64_t pointerTablePointersSize = sizeof(LGGOCXXAddress)*pointerCount; + uint64_t pointerTablePointersSize = HASHTABLE_RECORD_SIZE*pointerCount; uint64_t *pointerTablePointers = (uint64_t *)malloc(pointerTablePointersSize); unsigned char *pointerTableHashes = (unsigned char *)malloc(CC_SHA224_DIGEST_LENGTH*sizeof(unsigned char)*pointerCount); @@ -211,8 +211,8 @@ LGGOCXXSharedMemoryDescriptor LGGOCXXWritableStoreSegment::serializeToMemory(voi currentOffset = 32; - bcopy(pointerTablePointers, &segmentData[currentOffset], (sizeof(LGGOCXXAddress)*pointerCount)); - currentOffset = currentOffset + (sizeof(LGGOCXXAddress)*pointerCount); + bcopy(pointerTablePointers, &segmentData[currentOffset], HASHTABLE_RECORD_SIZE*pointerCount); + currentOffset = currentOffset + (HASHTABLE_RECORD_SIZE*pointerCount); free(pointerTablePointers); @@ -228,4 +228,5 @@ LGGOCXXSharedMemoryDescriptor LGGOCXXWritableStoreSegment::serializeToMemory(voi free(hashTableObjects); return LGGOCXXSharedMemoryDescriptor(new LGGOCXXMemoryDescriptor(segmentData, totalSize, false, true)); -} \ No newline at end of file +} +#endif \ No newline at end of file diff --git a/Source/Storage/LGGOCXXStoreSegment.h b/Source/Storage/LGGOCXXStoreSegment.h index 1726ee2..f20b288 100644 --- a/Source/Storage/LGGOCXXStoreSegment.h +++ b/Source/Storage/LGGOCXXStoreSegment.h @@ -47,10 +47,11 @@ typedef std::tr1::shared_ptr LGGOCXXSharedStoreSegment; virtual class LGGOCXXBaseStoreSegment : public std::tr1::enable_shared_from_this { public: - virtual void setDescriptorForAddress(const LGGOCXXSharedMemoryDescriptor &object, LGGOCXXAddress address) = 0; - virtual LGGOCXXSharedMemoryDescriptor getDescriptorForAddress (LGGOCXXAddress address) = 0; + virtual void setDescriptorForAddress(const LGGOCXXSharedMemoryDescriptor &object, uint64_t address) = 0; + virtual LGGOCXXSharedMemoryDescriptor getDescriptorForAddress (uint64_t address) = 0; }; +#if 0 class LGGOCXXWritableStoreSegment : public LGGOCXXBaseStoreSegment { private: std::map memoryObjects; @@ -58,9 +59,10 @@ class LGGOCXXWritableStoreSegment : public LGGOCXXBaseStoreSegment { public: LGGOCXXSharedMemoryDescriptor serializeToMemory(void); - virtual void setDescriptorForAddress(const LGGOCXXSharedMemoryDescriptor &object, LGGOCXXAddress address); - virtual LGGOCXXSharedMemoryDescriptor getDescriptorForAddress (LGGOCXXAddress address); + virtual void setDescriptorForAddress(const LGGOCXXSharedMemoryDescriptor &object, uint64_t address); + virtual LGGOCXXSharedMemoryDescriptor getDescriptorForAddress (uint64_t address); }; +#endif class LGGOCXXStoreSegment : public LGGOCXXBaseStoreSegment { private: @@ -74,8 +76,8 @@ class LGGOCXXStoreSegment : public LGGOCXXBaseStoreSegment { public: explicit LGGOCXXStoreSegment(LGGOCXXSharedMemoryDescriptor D); - virtual void setDescriptorForAddress(const LGGOCXXSharedMemoryDescriptor &object, LGGOCXXAddress address); - virtual LGGOCXXSharedMemoryDescriptor getDescriptorForAddress (LGGOCXXAddress address); + virtual void setDescriptorForAddress(const LGGOCXXSharedMemoryDescriptor &object, uint64_t address); + virtual LGGOCXXSharedMemoryDescriptor getDescriptorForAddress (uint64_t address); }; #endif \ No newline at end of file diff --git a/Source/Types/Collections/HackArray/LGGOCXXHackArray.cpp b/Source/Types/Collections/HackArray/LGGOCXXHackArray.cpp index 3265e62..e3b544c 100644 --- a/Source/Types/Collections/HackArray/LGGOCXXHackArray.cpp +++ b/Source/Types/Collections/HackArray/LGGOCXXHackArray.cpp @@ -26,37 +26,18 @@ uint64_t LGGOCXXHackArray::getCount(void) { return objects.size(); } -LGGOCXXSharedType LGGOCXXHackArray::getObjectAtIndex(uint64_t i) { - LGGOCXXSharedType retval; - +LGGOCXXSharedAddress LGGOCXXHackArray::getObjectAtIndex(uint64_t i) { assert(objects.size() > i); - LGGOCXXAddress address = objects[i]; - if (address.isNative()) { - //FIXME deal with this once addresses support native objects again - assert(0); - } else { - retval = getContext()->resolvedObjectForAddress(address); - } - return retval; + return LGGOCXXSharedAddress(objects[i]); } -LGGOCXXAddress LGGOCXXHackArray::getAddress(void) { - if (!address.isValid()) { - address = getContext()->getNextFreeAddress(); - //HACK - //Remove this once we have native LGGOAddresses - getContext()->setResolvedObjectForAddress(shared_from_this(), address); - } - return LGGOCXXAddress(); +void LGGOCXXHackArray::addObject(const LGGOCXXSharedAddress& object) { + objects.push_back(LGGOCXXWeakAddress(object)); } -void LGGOCXXHackArray::addObject(const LGGOCXXSharedType& object) { - objects.push_back(object->getAddress()); -} - -void LGGOCXXHackArray::insertObjectAtIndex(const LGGOCXXSharedType& object, uint64_t index) { - std::vector::iterator i = objects.begin()+index; - objects.insert(i, object->getAddress()); +void LGGOCXXHackArray::insertObjectAtIndex(const LGGOCXXSharedAddress& object, uint64_t index) { + std::vector::iterator i = objects.begin()+index; + objects.insert(i, LGGOCXXWeakAddress(object)); } void LGGOCXXHackArray::removeLastObject (void) { @@ -64,13 +45,17 @@ void LGGOCXXHackArray::removeLastObject (void) { } void LGGOCXXHackArray::removeObjectAtIndex(uint64_t index) { - std::vector::iterator i = objects.begin()+index; + std::vector::iterator i = objects.begin()+index; objects.erase(i); } -void LGGOCXXHackArray::replaceObjectAtIndexWithObject(const LGGOCXXSharedType& object, uint64_t index) { - std::vector::iterator i = objects.begin()+index; - objects[index] = object->getAddress(); +void LGGOCXXHackArray::replaceObjectAtIndexWithObject(const LGGOCXXSharedAddress& object, uint64_t index) { + std::vector::iterator i = objects.begin()+index; + objects[index] = LGGOCXXWeakAddress(object); +} + +uint64_t LGGOCXXHackArray::getTagValue (void) { + return 0; } LGGOCXXSharedMemoryDescriptor LGGOCXXHackArray::getSerializedData (void) { diff --git a/Source/Types/Collections/HackArray/LGGOCXXHackArray.h b/Source/Types/Collections/HackArray/LGGOCXXHackArray.h index b023a6e..2969764 100644 --- a/Source/Types/Collections/HackArray/LGGOCXXHackArray.h +++ b/Source/Types/Collections/HackArray/LGGOCXXHackArray.h @@ -34,22 +34,21 @@ class LGGOCXXObject; class LGGOCXXHackArray : public LGGOCXXType { private: - LGGOCXXAddress address; - std::vector objects; + std::vector objects; bool dirty:1; public: - LGGOCXXHackArray(LGGOCXXSharedStoreContext C) : LGGOCXXType(C), address(0), dirty(true) { } + LGGOCXXHackArray(void) : LGGOCXXType(), dirty(true) { } uint64_t getCount(void); - LGGOCXXSharedType getObjectAtIndex(uint64_t i); + LGGOCXXSharedAddress getObjectAtIndex(uint64_t i); - void addObject(const LGGOCXXSharedType& object); - void insertObjectAtIndex(const LGGOCXXSharedType& object, uint64_t index); + void addObject(const LGGOCXXSharedAddress& object); + void insertObjectAtIndex(const LGGOCXXSharedAddress& object, uint64_t index); void removeLastObject (void); void removeObjectAtIndex(uint64_t index); - void replaceObjectAtIndexWithObject(const LGGOCXXSharedType& object, uint64_t index); + void replaceObjectAtIndexWithObject(const LGGOCXXSharedAddress& object, uint64_t index); - virtual LGGOCXXAddress getAddress(void); + virtual uint64_t getTagValue (void); virtual LGGOCXXSharedMemoryDescriptor getSerializedData (void); virtual bool isDirty(void); virtual bool isDusty(void); diff --git a/Source/Types/LGGOCXXClass.cpp b/Source/Types/LGGOCXXClass.cpp index 8c181ed..377afcb 100644 --- a/Source/Types/LGGOCXXClass.cpp +++ b/Source/Types/LGGOCXXClass.cpp @@ -23,21 +23,10 @@ #include "LGGOCXXClass.h" -LGGOCXXClass::LGGOCXXClass(LGGOCXXSharedStoreContext C, std::string N) : LGGOCXXType(C), name(N), dirty(true) { +LGGOCXXClass::LGGOCXXClass(std::string N) : LGGOCXXType(), name(N), dirty(true) { } -LGGOCXXAddress LGGOCXXClass::getAddress (void) { - if (address.isValid()) { - address = getContext()->getNextFreeAddress(); - //HACK - //Remove this once we have native LGGOAddresses - getContext()->setResolvedObjectForAddress(shared_from_this(), address); - } - - return address; -} - void LGGOCXXClass::addProperty(std::string name, LGGOCXXScalarEncodingType type) { assert(relations.count(name) == 0); //While we can structurally support scheme style duality, ObjC can't properties[name] = type; @@ -81,7 +70,7 @@ uint32_t LGGOCXXClass::getPropertyOffset(std::string name) { uint8_t tSize = ::typeSize(type); //Properties come after relations - uint32_t retval = sizeof(LGGOCXXAddress)*relations.size(); + uint32_t retval = LGGOCXXADDRESS_SERIALIZED_SIZE*relations.size(); std::map::iterator i; @@ -129,6 +118,9 @@ uint32_t LGGOCXXClass::getRelationOffset(std::string name) { return retval; } +uint64_t LGGOCXXClass::getTagValue (void) { + return 0; +} LGGOCXXSharedMemoryDescriptor LGGOCXXClass::getSerializedData (void) { return NULL_DESCRIPTOR; diff --git a/Source/Types/LGGOCXXClass.h b/Source/Types/LGGOCXXClass.h index 9e800be..d46aa96 100644 --- a/Source/Types/LGGOCXXClass.h +++ b/Source/Types/LGGOCXXClass.h @@ -36,13 +36,12 @@ typedef std::tr1::tuple properties; std::map relations; bool dirty:1; public: - LGGOCXXClass(LGGOCXXSharedStoreContext C, std::string N); + explicit LGGOCXXClass(std::string N); void addProperty(std::string name, LGGOCXXScalarEncodingType type); void addRelation(std::string name, LGGOCXXRelationEncodingType type, LGGOCXXRelationSemanticsType semantics); @@ -52,10 +51,9 @@ class LGGOCXXClass : public LGGOCXXType { LGGOCXXRelationEncodingType getRelationType(std::string name); LGGOCXXRelationSemanticsType getRelationSemantics(std::string name); uint32_t getRelationOffset(std::string name); - - virtual LGGOCXXAddress getAddress(void); - virtual LGGOCXXSharedMemoryDescriptor getSerializedData (void); + virtual uint64_t getTagValue (void); + virtual LGGOCXXSharedMemoryDescriptor getSerializedData (void); virtual bool isDirty(void); virtual bool isDusty(void); }; diff --git a/Source/Types/LGGOCXXNumber.cpp b/Source/Types/LGGOCXXNumber.cpp index 3098b43..3909839 100644 --- a/Source/Types/LGGOCXXNumber.cpp +++ b/Source/Types/LGGOCXXNumber.cpp @@ -27,11 +27,11 @@ #define LGGO_MAX_INT59 ((int64_t)0x03ffffffffffffff) #define LGGO_MIN_INT59 ((int64_t)(-1*LGGO_MAX_INT59)) -LGGOCXXNumber::LGGOCXXNumber(LGGOCXXSharedStoreContext C, int64_t N) : LGGOCXXType(C), dirty(true), address(0) { +LGGOCXXNumber::LGGOCXXNumber(int64_t N) : LGGOCXXType(), dirty(true), rawValue(N) { + rawValue = *((uint64_t *)&N); + if (N >= 0) { if (N <= LGGO_MAX_INT59) { - address = LGGOCXXAddress(((uint64_t)kLGGOAddressNumberType) | ((uint64_t)LGGOCXXIntegerTypeEncoding << 4) | ((uint64_t)N << 5)); - if (N > UINT32_MAX) { type = kLGGOCXX64BitUnsignedNumberType; } else if (N > UINT16_MAX) { @@ -44,15 +44,9 @@ LGGOCXXNumber::LGGOCXXNumber(LGGOCXXSharedStoreContext C, int64_t N) : LGGOCXXTy } else { assert(0 && "Deal with oversized ints"); - } - + } } else { if (N >= LGGO_MIN_INT59) { - //We do not use twos complement here because we don't always know how many bits our type is - uint64_t absValue = -1*N; - - address = LGGOCXXAddress(kLGGOAddressNumberType | LGGOCXXIntegerTypeEncoding << 4 | ((uint64_t)absValue << 5) | ((uint64_t)0x1 << 63)); - if (N < INT32_MIN) { type = kLGGOCXX64BitSignedNumberType; } else if (N < INT16_MIN) { @@ -72,12 +66,22 @@ LGGOCXXScalarEncodingType LGGOCXXNumber::getType(void) { return type; } -LGGOCXXAddress LGGOCXXNumber::getAddress(void) { - //HACK - //Remove this once we have native LGGOAddresses - getContext()->setResolvedObjectForAddress(shared_from_this(), address); - - return address; +uint64_t LGGOCXXNumber::getTagValue (void) { + switch(type) { + case kLGGOCXX64BitUnsignedNumberType: + case kLGGOCXX32BitUnsignedNumberType: + case kLGGOCXX16BitUnsignedNumberType: + case kLGGOCXX8BitUnsignedNumberType: + return ((uint64_t)kLGGOAddressNumberType) | ((uint64_t)LGGOCXXIntegerTypeEncoding << 4) | ((uint64_t)rawValue << 5); + case kLGGOCXX64BitSignedNumberType: + case kLGGOCXX32BitSignedNumberType: + case kLGGOCXX16BitSignedNumberType: + case kLGGOCXX8BitSignedNumberType: + return ((uint64_t)kLGGOAddressNumberType) | ((uint64_t)LGGOCXXIntegerTypeEncoding << 4) | ((*((int64_t *)&rawValue)) << 5) | (uint64_t)1 << 63; + default: + assert(0); + break; + } } LGGOCXXSharedMemoryDescriptor LGGOCXXNumber::getSerializedData(void) { @@ -93,21 +97,11 @@ bool LGGOCXXNumber::isDusty(void) { } int64_t LGGOCXXNumber::signedValue (void) { - const uint64_t addressValue = address.getAddressValue(); - bool signBit = (uint64_t)addressValue >> 63; - int64_t retval; - - uint64_t absValue = ((uint64_t)(addressValue & 0x7fffffffffffffff) >> 5); - if (signBit) { - retval = -1 * absValue; - } else { - retval = absValue; - } - return retval; + return *((int64_t *)&rawValue); } uint64_t LGGOCXXNumber::unsignedValue (void) { - return (address.getAddressValue() >> 5); + return *((uint64_t *)&rawValue); } float LGGOCXXNumber::floatValue(void) { diff --git a/Source/Types/LGGOCXXNumber.h b/Source/Types/LGGOCXXNumber.h index c4f1fee..880d536 100644 --- a/Source/Types/LGGOCXXNumber.h +++ b/Source/Types/LGGOCXXNumber.h @@ -42,12 +42,12 @@ typedef enum { class LGGOCXXNumber : public LGGOCXXType { private: + uint64_t rawValue; LGGOCXXSharedMemoryDescriptor descriptor; - LGGOCXXAddress address; LGGOCXXScalarEncodingType type; bool dirty:1; public: - explicit LGGOCXXNumber(LGGOCXXSharedStoreContext C, int64_t N); + explicit LGGOCXXNumber(int64_t N); LGGOCXXScalarEncodingType getType(void); int64_t signedValue (void); @@ -55,7 +55,7 @@ class LGGOCXXNumber : public LGGOCXXType { float floatValue(void); double doubleValue(void); - virtual LGGOCXXAddress getAddress(void); + virtual uint64_t getTagValue (void); virtual LGGOCXXSharedMemoryDescriptor getSerializedData (void); virtual bool isDirty(void); virtual bool isDusty(void); diff --git a/Source/Types/LGGOCXXString.cpp b/Source/Types/LGGOCXXString.cpp index 71c6731..f172759 100644 --- a/Source/Types/LGGOCXXString.cpp +++ b/Source/Types/LGGOCXXString.cpp @@ -27,20 +27,21 @@ #include "utf8.h" -LGGOCXXString::LGGOCXXString(LGGOCXXSharedStoreContext C, std::string S) - : LGGOCXXType(C), charLength(0), lengthCalculated(false), dirty(true), address(0) { +LGGOCXXString::LGGOCXXString(std::string S) + : LGGOCXXType(), charLength(0), lengthCalculated(false), dirty(true) { byteLength = S.size(); if(byteLength <= 7) { uint32_t i; - uint8_t *buffer = (uint8_t *)&address; + uint8_t buffer[8]; + buffer[0] = kLGGOAddressStringType | (uint8_t)byteLength << 4; for(i = 0; i < byteLength; ++i) { buffer[i+1] = S[i]; } - stringDescriptor = LGGOCXXSharedMemoryDescriptor(new LGGOCXXTaggedMemoryDescriptor(address)); + stringDescriptor = LGGOCXXSharedMemoryDescriptor(new LGGOCXXTaggedMemoryDescriptor(*((uint64_t *)&buffer[0]))); } else { uint8_t *buffer = static_cast(malloc(byteLength+1)); buffer[0] = kLGGOAddressStringType | (uint8_t)0xff << 4; @@ -51,6 +52,17 @@ LGGOCXXString::LGGOCXXString(LGGOCXXSharedStoreContext C, std::string S) } } +uint64_t LGGOCXXString::getTagValue (void) { + uint64_t retval = 0; + + if (byteLength <= 7) { + retval = *((uint64_t *)stringDescriptor->getData()); + } + + return retval; +} + + bool LGGOCXXString::isDirty(void) { return dirty; } @@ -109,18 +121,6 @@ uint16_t LGGOCXXString::getCharacterAtIndex(uint32_t index) { return retval; } -LGGOCXXAddress LGGOCXXString::getAddress(void) { - if (!address.isValid()) { - address = getContext()->getNextFreeAddress(); - } - - //HACK - //Remove this once we have native LGGOAddresses - getContext()->setResolvedObjectForAddress(shared_from_this(), address); - - return address; -} - LGGOCXXSharedMemoryDescriptor LGGOCXXString::getSerializedData (void) { return stringDescriptor; } \ No newline at end of file diff --git a/Source/Types/LGGOCXXString.h b/Source/Types/LGGOCXXString.h index 5ea6859..1b1adee 100644 --- a/Source/Types/LGGOCXXString.h +++ b/Source/Types/LGGOCXXString.h @@ -41,21 +41,19 @@ class LGGOCXXString : public LGGOCXXType { private: LGGOCXXSharedMemoryDescriptor stringDescriptor; - LGGOCXXAddress address; uint32_t charLength; uint32_t byteLength; uint8_t offset; bool lengthCalculated:1; bool dirty:1; public: - explicit LGGOCXXString(LGGOCXXSharedStoreContext C, std::string S); + explicit LGGOCXXString(std::string S); uint32_t getLength(void); // void getCharsInRage(uint16_t *buffer, uint32_t start, uint32_t len); uint16_t getCharacterAtIndex(uint32_t index); - virtual LGGOCXXAddress getAddress(void); + virtual uint64_t getTagValue (void); virtual LGGOCXXSharedMemoryDescriptor getSerializedData (void); - virtual bool isDirty(void); virtual bool isDusty(void); }; diff --git a/Source/Types/LGGOCXXType.cpp b/Source/Types/LGGOCXXType.cpp index b1f7524..4c77217 100644 --- a/Source/Types/LGGOCXXType.cpp +++ b/Source/Types/LGGOCXXType.cpp @@ -22,24 +22,26 @@ #include "LGGOCXXType.h" -LGGOCXXType::LGGOCXXType(const LGGOCXXSharedStoreContext &C) : context(C), clientData(NULL) { +LGGOCXXType::LGGOCXXType(void) : clientData(NULL) { + +} +LGGOCXXWeakAddress LGGOCXXType::getAddress(void) { + return address; } -LGGOCXXSharedStoreContext LGGOCXXType::getContext(void) { - return context; +void LGGOCXXType::setAddress (const LGGOCXXWeakAddress &A) { + address = A; } void *LGGOCXXType::getNativeObject(void) { return clientData; } +const LGGOCXXSharedStoreContext &LGGOCXXType::getContext(void) { + return address.getContext(); +} + void LGGOCXXType::setNativeObject(void *D) { - if (D) { - getContext()->nativeObjectRetain(D); - } - if (clientData) { - getContext()->nativeObjectRelease(clientData); - } clientData = D; } \ No newline at end of file diff --git a/Source/Types/LGGOCXXType.h b/Source/Types/LGGOCXXType.h index ff8d967..2fe4408 100644 --- a/Source/Types/LGGOCXXType.h +++ b/Source/Types/LGGOCXXType.h @@ -68,17 +68,21 @@ typedef enum { virtual class LGGOCXXType : public std::tr1::enable_shared_from_this { private: - LGGOCXXSharedStoreContext context; + LGGOCXXWeakAddress address; void *clientData; public: - LGGOCXXType(const LGGOCXXSharedStoreContext& C); - LGGOCXXSharedStoreContext getContext(void); + explicit LGGOCXXType(void); + LGGOCXXWeakAddress getAddress(void); + void setAddress (const LGGOCXXWeakAddress &A); + + const LGGOCXXSharedStoreContext& getContext(void); + void *getNativeObject(void); void setNativeObject(void *D); - virtual LGGOCXXAddress getAddress(void) = 0; virtual LGGOCXXSharedMemoryDescriptor getSerializedData (void) = 0; + virtual uint64_t getTagValue (void) = 0; virtual bool isDirty(void) = 0; virtual bool isDusty(void) = 0; }; diff --git a/Source/Utilities/LGGOCXXAddress.cpp b/Source/Utilities/LGGOCXXAddress.cpp new file mode 100644 index 0000000..84a7697 --- /dev/null +++ b/Source/Utilities/LGGOCXXAddress.cpp @@ -0,0 +1,309 @@ +/* Copyright (c) 2010 GLsoft.mobi + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. + + */ + + + +#include + +#include "LGGOCXXAddress.h" + +#include +#include + +#if 0 + +#define LG_LOG(fmt, ...) printf(fmt, __VA_ARGS__) + +#define LG_BACKTRACE() { \ + void* callstack[128]; \ + int i, frames = backtrace(callstack, 128); \ + char** strs = backtrace_symbols(callstack, frames); \ + for (i = 0; i < frames; ++i) { \ + printf("%s\n", strs[i]); \ + } \ + free(strs); \ +} + +#else + +#define LG_LOG(fmt, ...) while(0) +#define LG_BACKTRACE() while(0) + +#endif + + +#pragma mark - +#pragma mark Control Block Implementation + +LGGOCXXAddress::LGGOCXXAddress(const LGGOCXXSharedStoreContext& C, const LGGOCXXSharedType &T) + : context(C), strongRefCount(0), weakRefCount(0), type(T) { + //Weak declare this weakAddr at top of scope to guarantee the addr is not deleted during setup + LGGOCXXWeakAddress weakAddr(this); + T->setAddress(weakAddr); + address = context->getNextFreeAddress(); + context->setAddressForAddressValue(LGGOCXXWeakAddress(this), address); + LG_LOG("Create 0x%llx real address\n", getAddressValue()); + assert(type->getAddress().getAddressValue() == address); +} + +LGGOCXXAddress::LGGOCXXAddress(const LGGOCXXSharedStoreContext& C, const LGGOCXXSharedType &T, uint64_t A) + : context(C), strongRefCount(0), weakRefCount(0), type(T), address(A) { + //Weak declare this weakAddr at top of scope to guarantee the addr is not deleted during setup + LGGOCXXWeakAddress weakAddr(this); + T->setAddress(weakAddr); + context->setAddressForAddressValue(LGGOCXXWeakAddress(this), address); + LG_LOG("Create 0x%llx real address\n", getAddressValue()); + assert(type->getAddress().getAddressValue() == address); + assert(type->getAddress().getAddressValue() == A); +} + +const uint64_t LGGOCXXAddress::getAddressValue (void) { + return address; +} + +const LGGOSimpleType LGGOCXXAddress::getType (void) const { + return static_cast(address | (uint64_t)0x00ff); +} + +const bool LGGOCXXAddress::isNative (void) const { + return ((address | (uint64_t)0x00ff) == kLGGOAddressNativeType); +} + +const bool LGGOCXXAddress::isValid (void) const { + return address != 0; +} + + +uint64_t LGGOCXXAddress::getConcreteAddressValue (void) const { + return address; +} + +void LGGOCXXAddress::incrementStrongCount (void) { + LG_LOG("Counts:%u/%u 0x%lx\n", strongRefCount, weakRefCount, (uintptr_t)this); + LG_BACKTRACE(); + strongRefCount++; +} + +void LGGOCXXAddress::decrementStrongCount (void) { + LG_LOG("Counts:%u/%u 0x%lx\n", strongRefCount, weakRefCount, (uintptr_t)this); + LG_BACKTRACE(); + assert(strongRefCount > 0); + strongRefCount--; + + if (strongRefCount == 0 && weakRefCount == 0) { + delete this; + } +} + +void LGGOCXXAddress::incrementWeakCount (void) { + LG_LOG("Counts:%u/%u 0x%lx\n", strongRefCount, weakRefCount, (uintptr_t)this); + LG_BACKTRACE(); + weakRefCount++; +} + +void LGGOCXXAddress::decrementWeakCount (void) { + LG_LOG("Counts:%u/%u 0x%lx\n", strongRefCount, weakRefCount, (uintptr_t)this); + LG_BACKTRACE(); + assert(weakRefCount > 0); + weakRefCount--; + + if (strongRefCount == 0 && weakRefCount == 0) { + delete this; + } +} + + +bool LGGOCXXAddress::operator== (const LGGOCXXAddress& A) { + return (address == A.address); +} + +bool LGGOCXXAddress::operator> (const LGGOCXXAddress& b) const { + return address > b.address; +} + +bool LGGOCXXAddress::operator< (const LGGOCXXAddress& b) const { + return address < b.address; +} + +const LGGOCXXSharedStoreContext& LGGOCXXAddress::getContext(void) { + return context; +} + +#pragma mark - +#pragma mark Strong Pointer Implementation + +LGGOCXXSharedAddress::LGGOCXXSharedAddress(void) : address(NULL) { + //printf("Create NULL strong address\n"); +} + +LGGOCXXSharedAddress::LGGOCXXSharedAddress(const LGGOCXXWeakAddress& A) : address(A.address) { + if (address) { + address->incrementStrongCount(); + } +} + +LGGOCXXSharedAddress::LGGOCXXSharedAddress(const LGGOCXXSharedAddress& A) : address(A.address) { + if (address) { + address->incrementStrongCount(); + } +} + +LGGOCXXSharedAddress::LGGOCXXSharedAddress(const LGGOCXXSharedStoreContext& C, uint64_t A) { + assert(A != 0); + LGGOCXXSharedAddress existingAddress = C->getAddressForAddressValue(A); + if (existingAddress.isValid()) { + address = existingAddress.address; + address->incrementStrongCount(); + } else { + assert(0); + } + assert(address->getAddressValue() == A); + //printf("Create 0x%llx strong address\n", address->getAddressValue()); +} + +LGGOCXXSharedAddress::LGGOCXXSharedAddress(const LGGOCXXSharedStoreContext& C, const LGGOCXXSharedType &T) { + uint64_t tagValue = T->getTagValue(); + + if (tagValue) { + LGGOCXXSharedAddress existingAddress = C->getAddressForAddressValue(tagValue); + if (existingAddress.isValid()) { + address = existingAddress.address; + } else { + address = new LGGOCXXAddress(C, T, tagValue); + } + assert(address->getAddressValue() == tagValue); + //printf("Create 0x%llx strong address\n", address->getAddressValue()); + } else { + address = new LGGOCXXAddress(C, T); + } + address->incrementStrongCount(); + //printf("Create 0x%llx strong address\n", address->getAddressValue()); +} + + +LGGOCXXSharedAddress::~LGGOCXXSharedAddress(void) { + if (address) { + address->decrementStrongCount(); + } +} + +const LGGOCXXSharedStoreContext& LGGOCXXSharedAddress::getContext(void) { + assert(address != NULL); + return address->getContext(); +} + +uint64_t LGGOCXXSharedAddress::getAddressValue(void) { + return address->getAddressValue(); +} + +LGGOCXXSharedType LGGOCXXSharedAddress::getType (void) { + assert(address != NULL); + return address->getType(); +} + +void LGGOCXXSharedAddress::setType (const LGGOCXXSharedType& T) { + assert(address != NULL); + address->setType(T); +} + +bool LGGOCXXSharedAddress::isValid (void) { + return (address != NULL); +} + +LGGOCXXSharedType LGGOCXXSharedAddress::operator* (void) const { + assert(address != NULL); + return address->getType(); +} + +LGGOCXXSharedType LGGOCXXSharedAddress::operator-> (void) const { + assert(address != NULL); + return address->getType(); +} + +LGGOCXXSharedAddress& LGGOCXXSharedAddress::operator= (const LGGOCXXSharedAddress& A) { + if (address) { + address->decrementStrongCount(); + } + address = A.address; + if (address) { + address->incrementStrongCount(); + } + return *this; +} + +#pragma mark - +#pragma mark Weak Pointer Implementation + +LGGOCXXWeakAddress::LGGOCXXWeakAddress(void) : address(NULL) { +// printf("Create NULL weak address\n"); +} + +LGGOCXXWeakAddress::LGGOCXXWeakAddress(LGGOCXXAddress *A) : address(A) { +// printf("Create 0x%llx weak address\n", A->getAddressValue()); + if (address) { + address->incrementWeakCount(); + } +} + + +LGGOCXXWeakAddress::LGGOCXXWeakAddress(const LGGOCXXWeakAddress& A) : address(A.address) { + if (address) { + address->incrementWeakCount(); + } +} + +LGGOCXXWeakAddress::LGGOCXXWeakAddress(const LGGOCXXSharedAddress& A) : address(A.address) { + if (address) { + address->incrementWeakCount(); + } +} + +LGGOCXXWeakAddress::~LGGOCXXWeakAddress(void) { + if (address) { + address->decrementWeakCount(); + } +} + +const LGGOCXXSharedStoreContext& LGGOCXXWeakAddress::getContext(void) { + assert(address != NULL); + return address->getContext(); +} + +uint64_t LGGOCXXWeakAddress::getAddressValue(void) { + return address->getAddressValue(); +} + +bool LGGOCXXWeakAddress::isValid (void) { + return (address != NULL); +} + +LGGOCXXWeakAddress& LGGOCXXWeakAddress::operator= (const LGGOCXXWeakAddress& A) { + if (address) { + address->decrementWeakCount(); + } + address = A.address; + if (address) { + address->incrementWeakCount(); + } + return *this; +} + diff --git a/Source/Utilities/LGGOCXXAddress.h b/Source/Utilities/LGGOCXXAddress.h index 91dc4e1..24d0895 100644 --- a/Source/Utilities/LGGOCXXAddress.h +++ b/Source/Utilities/LGGOCXXAddress.h @@ -20,14 +20,17 @@ */ -// FIXME -// In order to avoid lookups and solve cycles this will need to become our core custom smart pointer class +class LGGOCXXSharedAddress; +class LGGOCXXWeakAddress; #include "LGGOCXXType.h" +#include "LGGOCXXStoreContext.h" #ifndef LGGOADDRESS_H #define LGGOADDRESS_H +#define LGGOCXXADDRESS_SERIALIZED_SIZE (8) + typedef enum { kLGGOAddressNativeType = 0, kLGGOAddressConstantType = 1, @@ -45,29 +48,89 @@ typedef enum { class LGGOCXXAddress { private: uint64_t address; + LGGOCXXSharedStoreContext context; + LGGOCXXSharedType type; + uint32_t strongRefCount; + uint32_t weakRefCount; public: - LGGOCXXAddress(const LGGOCXXAddress& A) : address(A.address) { } - explicit LGGOCXXAddress(uint64_t A = 0) : address(A) {} - const uint64_t getAddressValue (void) { return address; } + explicit LGGOCXXAddress(const LGGOCXXSharedStoreContext& C, const LGGOCXXSharedType &T, uint64_t A); + explicit LGGOCXXAddress(const LGGOCXXSharedStoreContext& C, const LGGOCXXSharedType &T); + const uint64_t getAddressValue (void); - const LGGOSimpleType getType (void) const { return static_cast(address | (uint64_t)0x00ff); } - const bool isNative (void) const { return ((address | (uint64_t)0x00ff) == kLGGOAddressNativeType); } - const bool isValid (void) const { return address != 0; } + const LGGOSimpleType getType (void) const; + const bool isNative (void) const; + const bool isValid (void) const; + uint64_t getConcreteAddressValue (void) const; - uint64_t getConcreteAddressValue (void) const { return address; } + void incrementStrongCount (void); + void decrementStrongCount (void); - bool operator== (const LGGOCXXAddress& A) { - return (address == A.address); - } + void incrementWeakCount (void); + void decrementWeakCount (void); + + const LGGOCXXSharedStoreContext& getContext(void); + + bool operator== (const LGGOCXXAddress& A); + bool operator> (const LGGOCXXAddress& b) const; + bool operator< (const LGGOCXXAddress& b) const; - bool operator> (const LGGOCXXAddress& b) const { - return address > b.address; + LGGOCXXSharedType getType (void) { + return type; } - bool operator< (const LGGOCXXAddress& b) const { - return address < b.address; + void setType (const LGGOCXXSharedType& T) { + type = T; } + + friend class LGGOCXXSharedAddress; + friend class LGGOCXXWeakAddress; +}; + +class LGGOCXXSharedAddress { +private: + LGGOCXXAddress *address; +public: + explicit LGGOCXXSharedAddress(const LGGOCXXWeakAddress& A); + LGGOCXXSharedAddress(const LGGOCXXSharedAddress& A); + LGGOCXXSharedAddress(const LGGOCXXSharedStoreContext& C, uint64_t A); + LGGOCXXSharedAddress(const LGGOCXXSharedStoreContext& C, const LGGOCXXSharedType &T); + LGGOCXXSharedAddress(void); + ~LGGOCXXSharedAddress(void); + + const LGGOCXXSharedStoreContext& getContext(void); + uint64_t getAddressValue(void); + + LGGOCXXSharedType getType (void); + + void setType (const LGGOCXXSharedType& T); + bool isValid (void); + + LGGOCXXSharedType operator* (void) const; + LGGOCXXSharedType operator-> (void) const; + + LGGOCXXSharedAddress& operator= (const LGGOCXXSharedAddress& A); + + friend class LGGOCXXWeakAddress; +}; + +class LGGOCXXWeakAddress { +private: + LGGOCXXAddress *address; +public: + LGGOCXXWeakAddress(void); + explicit LGGOCXXWeakAddress(const LGGOCXXSharedAddress& A); + explicit LGGOCXXWeakAddress(LGGOCXXAddress *A); + LGGOCXXWeakAddress(const LGGOCXXWeakAddress&A); + ~LGGOCXXWeakAddress(void); + + const LGGOCXXSharedStoreContext& getContext(void); + uint64_t getAddressValue(void); + bool isValid (void); + + LGGOCXXWeakAddress& operator= (const LGGOCXXWeakAddress& A); + + friend class LGGOCXXSharedAddress; }; #endif \ No newline at end of file diff --git a/Source/objc/LGGOClass.h b/Source/objc/LGGOClass.h index f9c7631..5bd1bf2 100644 --- a/Source/objc/LGGOClass.h +++ b/Source/objc/LGGOClass.h @@ -28,6 +28,5 @@ @interface LGGOClass : NSObject - (id) initWithName:(NSString *)name_ inContext:(LGGOGraphContext *)context_; -- (id)initWithGraphObject:(const LGGOCXXSharedType &)graphObject inContext:(LGGOGraphContext *)context_ ; - +- (id)initWithGraphObject:(const LGGOCXXSharedAddress &)graphObject inContext:(LGGOGraphContext *)context_; @end diff --git a/Source/objc/LGGOClass.mm b/Source/objc/LGGOClass.mm index d082107..07b93a8 100644 --- a/Source/objc/LGGOClass.mm +++ b/Source/objc/LGGOClass.mm @@ -27,40 +27,44 @@ of this software and associated documentation files (the "Software"), to deal #import "LGGOClass.h" @interface LGGOClass () { - LGGOCXXSharedType sharedType; + LGGOCXXSharedAddress address; LGGOGraphContext *graphContext; } +@property (nonatomic, readonly) LGGOCXXSharedAddress address; + @end @implementation LGGOClass -- (id) initWithName:(NSString *)name_ inContext:(LGGOGraphContext *)context_ { +- (id)initWithGraphObject:(const LGGOCXXSharedAddress &)graphObject inContext:(LGGOGraphContext *)context_ { self = [super init]; - + if (self) { - sharedType = LGGOCXXSharedType(new LGGOCXXClass(context_.CXXContext, std::string(name_.UTF8String))); + address = graphObject; graphContext = [context_ retain]; - sharedType->setNativeObject(self); + address->setNativeObject(self); } return self; } -- (id)initWithGraphObject:(const LGGOCXXSharedType &)graphObject inContext:(LGGOGraphContext *)context_ { - self = [super init]; +- (id) initWithName:(NSString *)name_ inContext:(LGGOGraphContext *)context_ { + self = [super init]; if (self) { - sharedType = graphObject; + LGGOCXXSharedType type(new LGGOCXXClass(std::string(name_.UTF8String))); + address = LGGOCXXSharedAddress(context_.CXXContext, type); graphContext = [context_ retain]; - sharedType->setNativeObject(self); + address->setNativeObject(self); } - - return self; + + return self; } - (void) dealloc { + address->setNativeObject(NULL); [graphContext release]; [super dealloc]; diff --git a/Source/objc/LGGOGraphContext.h b/Source/objc/LGGOGraphContext.h index 6153a3c..30e7a7d 100644 --- a/Source/objc/LGGOGraphContext.h +++ b/Source/objc/LGGOGraphContext.h @@ -27,6 +27,7 @@ #if defined __cplusplus #include "LGGOCXXStoreContext.h" #include "LGGOCXXType.h" +#include "LGGOCXXAddress.h" #endif @interface LGGOGraphContext : NSObject @@ -35,8 +36,8 @@ - (id)initWithCXXContext:(const LGGOCXXSharedStoreContext&)context_; @property (copy, nonatomic) id rootObject; -- (id) transmuteToNativeObject:(LGGOCXXSharedType)graphObject; -- (LGGOCXXSharedType) transmuteToGraphObject:(id)object; +- (id) transmuteToNativeObject:(LGGOCXXSharedAddress)address; +- (LGGOCXXSharedAddress) transmuteToGraphObject:(id)object; @property (nonatomic, readonly) LGGOCXXSharedStoreContext CXXContext; #endif diff --git a/Source/objc/LGGOGraphContext.mm b/Source/objc/LGGOGraphContext.mm index e4f72a1..5067630 100644 --- a/Source/objc/LGGOGraphContext.mm +++ b/Source/objc/LGGOGraphContext.mm @@ -30,9 +30,9 @@ of this software and associated documentation files (the "Software"), to deal #import "LGGONumber.h" #import "LGGOMutableArray.h" -@protocol LGGOCXXSharedType +@protocol LGGOCXXSharedAddress -@property (nonatomic, readonly) LGGOCXXSharedType sharedType; +@property (nonatomic, readonly) LGGOCXXSharedAddress address; @end @@ -65,51 +65,54 @@ - (void)setRootObject:(id)rootObject { // This function returns a graph object from a normal object. It will grab the underlying // graph object, or make one (without an attached native object) if necessary. -- (id) transmuteToNativeObject:(LGGOCXXSharedType)graphObject { - id retval = (id)graphObject->getNativeObject(); +- (id) transmuteToNativeObject:(LGGOCXXSharedAddress)address { + id retval = (id)(*address)->getNativeObject(); if (!retval) { - std::tr1::shared_ptr lggoArray = std::tr1::dynamic_pointer_cast(graphObject); + std::tr1::shared_ptr lggoArray = std::tr1::dynamic_pointer_cast(*address); if (lggoArray.get()) { - return [[[LGGOMutableArray alloc] initWithGraphObject:graphObject inContext:self] autorelease]; + return [[[LGGOMutableArray alloc] initWithGraphObject:address inContext:self] autorelease]; } - std::tr1::shared_ptr lggoString = std::tr1::dynamic_pointer_cast(graphObject); + std::tr1::shared_ptr lggoString = std::tr1::dynamic_pointer_cast(*address); if (lggoString.get()) { - return [[[LGGOString alloc] initWithGraphObject:graphObject inContext:self] autorelease]; + return [[[LGGOString alloc] initWithGraphObject:address inContext:self] autorelease]; } - std::tr1::shared_ptr lggoNumber = std::tr1::dynamic_pointer_cast(graphObject); + std::tr1::shared_ptr lggoNumber = std::tr1::dynamic_pointer_cast(*address); if (lggoNumber.get()) { - return [[[LGGONumber alloc] initWithGraphObject:graphObject inContext:self] autorelease]; + return [[[LGGONumber alloc] initWithGraphObject:address inContext:self] autorelease]; } - - } return retval; } -- (LGGOCXXSharedType) transmuteToGraphObject:(id)object { - LGGOCXXSharedType retval; +- (LGGOCXXSharedAddress) transmuteToGraphObject:(id)object { + LGGOCXXSharedAddress retval; - if ([object respondsToSelector:@selector(LGGOCXXSharedType)]) { - id lggoObject = object; - retval = [lggoObject sharedType]; + if ([object respondsToSelector:@selector(address)]) { + id lggoObject = object; + retval = [lggoObject address]; + retval->setNativeObject(object); } else if ([object isKindOfClass:[NSString class]]) { NSString *string = object; - retval = LGGOCXXSharedType(new LGGOCXXString(CXXContext, string.UTF8String)); + retval = LGGOCXXSharedAddress(self.CXXContext, LGGOCXXSharedType(new LGGOCXXString(string.UTF8String))); + retval->setNativeObject(object); } else if ([object isKindOfClass:[NSNumber class]]) { //FIXME this needs improvement for floats NSNumber *number = object; - retval = LGGOCXXSharedType(new LGGOCXXNumber(CXXContext, number.longLongValue)); + LGGOCXXSharedAddress temp(self.CXXContext, LGGOCXXSharedType(new LGGOCXXNumber(number.longLongValue))); + retval = temp; + retval->setNativeObject(object); } else if ([object isKindOfClass:[NSArray class]]) { NSArray *array = object; - retval = LGGOCXXSharedType(new LGGOCXXHackArray(CXXContext)); - std::tr1::shared_ptr lggoArray = std::tr1::dynamic_pointer_cast(retval); + retval = LGGOCXXSharedAddress(self.CXXContext, LGGOCXXSharedType(new LGGOCXXHackArray())); + std::tr1::shared_ptr lggoArray = std::tr1::dynamic_pointer_cast(*retval); [array enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) { lggoArray->addObject([self transmuteToGraphObject:obj]); }]; + retval->setNativeObject(object); } else { assert(0); } diff --git a/Source/objc/LGGOMutableArray.h b/Source/objc/LGGOMutableArray.h index f43db4b..70700c0 100644 --- a/Source/objc/LGGOMutableArray.h +++ b/Source/objc/LGGOMutableArray.h @@ -22,6 +22,7 @@ #import #if defined __cplusplus +#include "LGGOCXXAddress.h" #include "LGGOCXXType.h" #endif @@ -29,6 +30,6 @@ - (id)initInContext:(LGGOGraphContext *)context_; #if defined __cplusplus -- (id)initWithGraphObject:(const LGGOCXXSharedType &)graphObject inContext:(LGGOGraphContext *)context_; +- (id)initWithGraphObject:(const LGGOCXXSharedAddress &)graphObject inContext:(LGGOGraphContext *)context_; #endif @end diff --git a/Source/objc/LGGOMutableArray.mm b/Source/objc/LGGOMutableArray.mm index 9eb70ff..aa791c9 100644 --- a/Source/objc/LGGOMutableArray.mm +++ b/Source/objc/LGGOMutableArray.mm @@ -27,7 +27,7 @@ of this software and associated documentation files (the "Software"), to deal #import "LGGOMutableArray.h" @interface LGGOMutableArray () { - LGGOCXXSharedType sharedType; + LGGOCXXSharedAddress address; LGGOGraphContext *graphContext; } @@ -35,41 +35,56 @@ @interface LGGOMutableArray () { @implementation LGGOMutableArray -- (id)initWithGraphObject:(const LGGOCXXSharedType &)graphObject inContext:(LGGOGraphContext *)context_ { - self = [super init]; +- (id)initWithGraphObject:(const LGGOCXXSharedAddress &)graphObject inContext:(LGGOGraphContext *)context_ { + self = [super init]; + id retval; if (self) { - sharedType = graphObject; - graphContext = [context_ retain]; - sharedType->setNativeObject(self); + address = graphObject; + + id existingObject = (id)address->getNativeObject(); + + if (existingObject) { + [self release]; + retval = [existingObject retain]; + } else { + graphContext = [context_ retain]; + address->setNativeObject(self); + } } - return self; + return retval; } - (id)initInContext:(LGGOGraphContext *)context_ { self = [super init]; - if (self) { - sharedType = LGGOCXXSharedType(new LGGOCXXHackArray(context_.CXXContext)); + if (self) { + LGGOCXXSharedType type(new LGGOCXXHackArray()); + address = LGGOCXXSharedAddress(context_.CXXContext, type); graphContext = [context_ retain]; - sharedType->setNativeObject(self); + address->setNativeObject(self); } return self; } - (void)dealloc { + if (address.isValid()) { + address->setNativeObject(NULL); + } [graphContext release]; [super dealloc]; } - (NSUInteger)count { - return std::tr1::dynamic_pointer_cast(sharedType)->getCount(); + NSUInteger retval = std::tr1::dynamic_pointer_cast(*address)->getCount(); + return retval; } + - (id)objectAtIndex:(NSUInteger)index { - LGGOCXXSharedType typedObject = std::tr1::dynamic_pointer_cast(sharedType)->getObjectAtIndex(index); + LGGOCXXSharedAddress typedObject = std::tr1::dynamic_pointer_cast(*address)->getObjectAtIndex(index); id retval = (id)typedObject->getNativeObject(); if (!retval) { @@ -80,29 +95,29 @@ - (id)objectAtIndex:(NSUInteger)index { } - (void)addObject:(id)anObject { - LGGOCXXSharedType object = [graphContext transmuteToGraphObject:anObject]; + LGGOCXXSharedAddress objectAddress = [graphContext transmuteToGraphObject:anObject]; - std::tr1::dynamic_pointer_cast(sharedType)->addObject(object); + std::tr1::dynamic_pointer_cast(*address)->addObject(objectAddress); } - (void)insertObject:(id)anObject atIndex:(NSUInteger)index { - LGGOCXXSharedType object = [graphContext transmuteToGraphObject:anObject]; + LGGOCXXSharedAddress objectAddress = [graphContext transmuteToGraphObject:anObject]; - std::tr1::dynamic_pointer_cast(sharedType)->insertObjectAtIndex(object, index); + std::tr1::dynamic_pointer_cast(*address)->insertObjectAtIndex(objectAddress, index); } - (void)removeLastObject { - std::tr1::dynamic_pointer_cast(sharedType)->removeLastObject(); + std::tr1::dynamic_pointer_cast(*address)->removeLastObject(); } - (void)removeObjectAtIndex:(NSUInteger)index { - std::tr1::dynamic_pointer_cast(sharedType)->removeObjectAtIndex(index); + std::tr1::dynamic_pointer_cast(*address)->removeObjectAtIndex(index); } - (void)replaceObjectAtIndex:(NSUInteger)index withObject:(id)anObject { - LGGOCXXSharedType object = [graphContext transmuteToGraphObject:anObject]; + LGGOCXXSharedAddress objectAddress = [graphContext transmuteToGraphObject:anObject]; - std::tr1::dynamic_pointer_cast(sharedType)->replaceObjectAtIndexWithObject(object, index); + std::tr1::dynamic_pointer_cast(*address)->replaceObjectAtIndexWithObject(objectAddress, index); } @end diff --git a/Source/objc/LGGONumber.h b/Source/objc/LGGONumber.h index f68d91a..d6b7d46 100644 --- a/Source/objc/LGGONumber.h +++ b/Source/objc/LGGONumber.h @@ -29,6 +29,6 @@ - (id)initWithNumber:(NSNumber *)number_ inContext:(LGGOGraphContext *)context_; #if defined __cplusplus -- (id)initWithGraphObject:(const LGGOCXXSharedType &)graphObject inContext:(LGGOGraphContext *)context_; +- (id)initWithGraphObject:(const LGGOCXXSharedAddress &)graphObject inContext:(LGGOGraphContext *)context_; #endif @end \ No newline at end of file diff --git a/Source/objc/LGGONumber.mm b/Source/objc/LGGONumber.mm index 49339e6..9522d71 100644 --- a/Source/objc/LGGONumber.mm +++ b/Source/objc/LGGONumber.mm @@ -30,49 +30,74 @@ of this software and associated documentation files (the "Software"), to deal #import "LGGONumber.h" @interface LGGONumber () { - LGGOCXXSharedType sharedType; + LGGOCXXSharedAddress address; LGGOGraphContext *graphContext; } -@property LGGOCXXSharedType sharedType; +@property LGGOCXXSharedAddress address; @end @implementation LGGONumber -- (id)initWithNumber:(NSNumber *)number_ inContext:(LGGOGraphContext *)context_ { +- (id)initWithGraphObject:(const LGGOCXXSharedAddress &)graphObject inContext:(LGGOGraphContext *)context_ { self = [super init]; - - if (self) { - sharedType = LGGOCXXSharedType(new LGGOCXXNumber(context_.CXXContext, (int64_t)(number_.longLongValue))); - graphContext = [context_ retain]; - sharedType->setNativeObject(self); + id retval; + + if (self) { + address = graphObject; - + id existingObject = (id)address->getNativeObject(); + + if (existingObject) { + address = LGGOCXXSharedAddress(); + [self release]; + retval = [existingObject retain]; + } else { + graphContext = [context_ retain]; + address->setNativeObject(self); + } } - - return self; + + return retval; } -- (id)initWithGraphObject:(const LGGOCXXSharedType &)graphObject inContext:(LGGOGraphContext *)context_ { - self = [super init]; + +- (id)initWithNumber:(NSNumber *)number_ inContext:(LGGOGraphContext *)context_ { + self = [super init]; + id retval; if (self) { - sharedType = graphObject; - graphContext = [context_ retain]; - sharedType->setNativeObject(self); + LGGOCXXSharedType type(new LGGOCXXNumber(number_.longLongValue)); + address = LGGOCXXSharedAddress(context_.CXXContext, type); + + id existingObject = (id)address->getNativeObject(); + + if (existingObject) { + //We do this here so that the when the ObjC runtime destructs the C++ ivar it has an empty object to chew on + address = LGGOCXXSharedAddress(); + [self release]; + retval = [existingObject retain]; + } else { + retval = self; + graphContext = [context_ retain]; + address->setNativeObject(self); + } } - - return self; + + return retval; } - (void) dealloc { + if (address.isValid()) { + address->setNativeObject(NULL); + } [graphContext release]; [super dealloc]; } - (void)getValue:(void *)value_ { - std::tr1::shared_ptr sharedNumber = std::tr1::dynamic_pointer_cast(sharedType); + std::tr1::shared_ptr sharedNumber = std::tr1::dynamic_pointer_cast(*address); switch(sharedNumber->getType()) { case kLGGOCXX8BitSignedNumberType: case kLGGOCXX16BitSignedNumberType: @@ -95,7 +120,7 @@ - (void)getValue:(void *)value_ { #define LGGO_NUMBER_ACCESSOR(datatype, name) \ - (datatype)name { \ - std::tr1::shared_ptr sharedNumber = std::tr1::dynamic_pointer_cast(sharedType); \ + std::tr1::shared_ptr sharedNumber = std::tr1::dynamic_pointer_cast(*address); \ datatype retval; \ switch(sharedNumber->getType()) { \ case kLGGOCXX8BitSignedNumberType : \ @@ -131,7 +156,7 @@ - (datatype)name { - (const char *)objCType { const char *retval; - switch(std::tr1::dynamic_pointer_cast(sharedType)->getType()) { + switch(std::tr1::dynamic_pointer_cast(*address)->getType()) { case kLGGOCXX8BitSignedNumberType : retval = "c"; break; case kLGGOCXX8BitUnsignedNumberType : retval = "C"; break; case kLGGOCXX16BitSignedNumberType : retval = "i"; break; diff --git a/Source/objc/LGGOString.h b/Source/objc/LGGOString.h index ff9da93..2576c12 100644 --- a/Source/objc/LGGOString.h +++ b/Source/objc/LGGOString.h @@ -27,6 +27,6 @@ - (id) initWithString:(NSString *)string_ inContext:(LGGOGraphContext *)context_; #if defined __cplusplus -- (id)initWithGraphObject:(const LGGOCXXSharedType &)graphObject inContext:(LGGOGraphContext *)context_; +- (id)initWithGraphObject:(const LGGOCXXSharedAddress &)graphObject inContext:(LGGOGraphContext *)context_; #endif @end diff --git a/Source/objc/LGGOString.mm b/Source/objc/LGGOString.mm index 6f5b1a5..e4f81fd 100644 --- a/Source/objc/LGGOString.mm +++ b/Source/objc/LGGOString.mm @@ -28,54 +28,78 @@ of this software and associated documentation files (the "Software"), to deal @interface LGGOString () { - LGGOCXXSharedType sharedType; + LGGOCXXSharedAddress address; LGGOGraphContext *graphContext; } -@property LGGOCXXSharedType sharedType; +@property LGGOCXXSharedAddress address; @end @implementation LGGOString -- (id) initWithString:(NSString *)string_ inContext:(LGGOGraphContext *)context_ { - self = [super init]; - +- (id)initWithGraphObject:(const LGGOCXXSharedAddress &)graphObject inContext:(LGGOGraphContext *)context_ { + self = [super init]; + id retval; + if (self) { - sharedType = LGGOCXXSharedType(new LGGOCXXString(context_.CXXContext, std::string(string_.UTF8String))); - graphContext = [context_ retain]; - sharedType->setNativeObject(self); + address = graphObject; + + id existingObject = (id)address->getNativeObject(); + + if (existingObject) { + [self release]; + retval = [existingObject retain]; + } else { + graphContext = [context_ retain]; + address->setNativeObject(self); + } } - return self; + return retval; } -- (id)initWithGraphObject:(const LGGOCXXSharedType &)graphObject inContext:(LGGOGraphContext *)context_ { - self = [super init]; +- (id)initWithString:(NSString *)string_ inContext:(LGGOGraphContext *)context_ { + self = [super init]; + id retval; if (self) { - sharedType = graphObject; - graphContext = [context_ retain]; - sharedType->setNativeObject(self); + LGGOCXXSharedType type(new LGGOCXXString(std::string(string_.UTF8String))); + address = LGGOCXXSharedAddress(context_.CXXContext, type); + + id existingObject = (id)address->getNativeObject(); + + if (existingObject) { + address = LGGOCXXSharedAddress(); + [self release]; + retval = [existingObject retain]; + } else { + retval = self; + graphContext = [context_ retain]; + address->setNativeObject(self); + } } - - return self; + + return retval; } - (void) dealloc { + if (address.isValid()) { + address->setNativeObject(NULL); + } [graphContext release]; [super dealloc]; } - (NSUInteger)length { - NSUInteger retval = std::tr1::dynamic_pointer_cast(sharedType)->getLength(); + NSUInteger retval = std::tr1::dynamic_pointer_cast(*address)->getLength(); return retval; } - (unichar)characterAtIndex:(NSUInteger)index { - return std::tr1::dynamic_pointer_cast(sharedType)->getCharacterAtIndex(index); + return std::tr1::dynamic_pointer_cast(*address)->getCharacterAtIndex(index); } #if 0 diff --git a/Tests/LGGOArrayTests.m b/Tests/LGGOArrayTests.m index 28a3cba..9a37cf7 100644 --- a/Tests/LGGOArrayTests.m +++ b/Tests/LGGOArrayTests.m @@ -36,6 +36,7 @@ of this software and associated documentation files (the "Software"), to deal @implementation LGGOArrayTests +#if 0 - (void) testCreation { LGGOGraph *graph = [[LGGOGraph alloc] initWithURL:[NSURL URLWithString:@"file:///tmp/"]]; LGGOGraphContext *context = [graph newContext]; @@ -45,13 +46,10 @@ - (void) testCreation { for(NSUInteger i = 0; i < ARRAY_COUNT; i++) { [array insertObject:[NSNumber numberWithUnsignedInteger:i] atIndex:0]; [graphArray insertObject:[NSNumber numberWithUnsignedInteger:i] atIndex:0]; - STAssertEqualObjects(array, graphArray, nil); } STAssertEquals((NSUInteger)ARRAY_COUNT, graphArray.count, nil); -// [self validateArrayTree:graphArray.rootNode]; - [graphArray release]; [graph release]; [array release]; @@ -109,6 +107,7 @@ - (void) testLastObject { [graphArray release]; [graph release]; } -#endif +#endif +#endif @end \ No newline at end of file diff --git a/Tests/LGGOCXXStoreContextTests.mm b/Tests/LGGOCXXStoreContextTests.mm index 871e361..2f6ffc7 100644 --- a/Tests/LGGOCXXStoreContextTests.mm +++ b/Tests/LGGOCXXStoreContextTests.mm @@ -23,6 +23,11 @@ of this software and associated documentation files (the "Software"), to deal #include +#import "LGGOGraph.h" +#import "LGGOGraphContext.h" +#import "LGGONumber.h" +#import "LGGOString.h" + #include "LGGOCXXStore.h" #include "LGGOCXXStoreContext.h" @@ -30,6 +35,7 @@ of this software and associated documentation files (the "Software"), to deal @implementation LGGOCXXStoreContextTests +#if 0 - (void) testContextCreation { char path[32]; strlcpy(path, "/tmp/GraphObjects.XXXXXX", 32); @@ -37,5 +43,27 @@ - (void) testContextCreation { LGGOCXXSharedStore store = LGGOCXXSharedStore(new LGGOCXXStore(path)); LGGOCXXSharedStoreContext context = LGGOCXXSharedStoreContext(store->newContext()); } +#endif + +- (void) testObjectUniquing { + LGGOGraph *graph = [[LGGOGraph alloc] initWithURL:[NSURL URLWithString:@"file:///tmp/"]]; + LGGOGraphContext *context = [graph newContext]; + + LGGONumber *testNumber1 = [[LGGONumber alloc] initWithNumber:[NSNumber numberWithInt:2] inContext:context]; + LGGONumber *testNumber2 = [[LGGONumber alloc] initWithNumber:[NSNumber numberWithInt:2] inContext:context]; + STAssertTrue(testNumber1 == testNumber2, nil); + + LGGOString *testString1 = [[LGGOString alloc] initWithString:@"ABC" inContext:context]; + LGGOString *testString2 = [[LGGOString alloc] initWithString:@"ABC" inContext:context]; + STAssertTrue(testString1 == testString2, nil); + + [testNumber1 release]; + [testNumber2 release]; + [testString1 release]; + [testString2 release]; + + [context release]; + [graph release]; +} @end diff --git a/Tests/LGGOCXXStoreSegmentTests.mm b/Tests/LGGOCXXStoreSegmentTests.mm index 1c8d12d..2703af0 100644 --- a/Tests/LGGOCXXStoreSegmentTests.mm +++ b/Tests/LGGOCXXStoreSegmentTests.mm @@ -26,12 +26,14 @@ of this software and associated documentation files (the "Software"), to deal @implementation LGGOCXXStoreSegmentTests +#if 0 - (void) testWritableSegmentCreation { LGGOCXXWritableStoreSegment *segment = new LGGOCXXWritableStoreSegment; STAssertTrue(segment != nil, nil); delete segment; } + - (void) testWritableSegmentStorage { LGGOCXXWritableStoreSegment *segment = new LGGOCXXWritableStoreSegment; @@ -90,5 +92,6 @@ - (void) testSegmentSerialization { free(data); } } +#endif @end From 690725bfeaea3f68ff0e50c69c0656527d191141 Mon Sep 17 00:00:00 2001 From: Louis Gerbarg Date: Mon, 8 Nov 2010 23:30:41 -0800 Subject: [PATCH 4/9] Removed LGGOCXXSharedType, since the type data should be gated by LGGOCXXAddress, which is a refcounted smart pointer as well --- Source/Storage/LGGOCXXStoreContext.cpp | 6 ++-- Source/Storage/LGGOCXXStoreContext.h | 4 +-- Source/Types/LGGOCXXType.h | 6 ++-- Source/Utilities/LGGOCXXAddress.cpp | 14 ++++----- Source/Utilities/LGGOCXXAddress.h | 20 ++++++------- Source/objc/LGGOClass.mm | 3 +- Source/objc/LGGOGraphContext.mm | 20 ++++++------- Source/objc/LGGOMutableArray.mm | 18 ++++++------ Source/objc/LGGONumber.mm | 39 +++++++++++++------------- Source/objc/LGGOString.mm | 11 +++----- 10 files changed, 67 insertions(+), 74 deletions(-) diff --git a/Source/Storage/LGGOCXXStoreContext.cpp b/Source/Storage/LGGOCXXStoreContext.cpp index f38ead9..f769788 100644 --- a/Source/Storage/LGGOCXXStoreContext.cpp +++ b/Source/Storage/LGGOCXXStoreContext.cpp @@ -91,14 +91,14 @@ void LGGOCXXStoreContext::commit (void) { //FIXME we need to use a locking protocol here } -LGGOCXXSharedType LGGOCXXStoreContext::rootObject(void) { +LGGOCXXType * LGGOCXXStoreContext::rootObject(void) { LGGOCXXSharedAddress address(getAddress(1<<4)); return *address; } -void LGGOCXXStoreContext::setRootObject(const LGGOCXXSharedType &object) { +void LGGOCXXStoreContext::setRootObject(LGGOCXXType *T) { LGGOCXXSharedAddress address(shared_from_this(), 1<<4); - address.setType(object); + address.setType(T); } LGGOCXXSharedAddress LGGOCXXStoreContext::getAddress (uint64_t address) { diff --git a/Source/Storage/LGGOCXXStoreContext.h b/Source/Storage/LGGOCXXStoreContext.h index 4220fdb..3f8f872 100644 --- a/Source/Storage/LGGOCXXStoreContext.h +++ b/Source/Storage/LGGOCXXStoreContext.h @@ -61,8 +61,8 @@ class LGGOCXXStoreContext : public std::tr1::enable_shared_from_this virtual class LGGOCXXType; -typedef std::tr1::shared_ptr LGGOCXXSharedType; -typedef std::tr1::weak_ptr LGGOCXXWeakType; +//typedef std::tr1::shared_ptr LGGOCXXSharedType; +//typedef std::tr1::weak_ptr LGGOCXXWeakType; #ifndef LGGOCXXTYPE_H #define LGGOCXXTYPE_H @@ -66,7 +66,7 @@ typedef enum { kLGGOCXXClassByReferenceType = 1 } LGGOCXXRelationSemanticsType; -virtual class LGGOCXXType : public std::tr1::enable_shared_from_this { +class LGGOCXXType { private: LGGOCXXWeakAddress address; void *clientData; diff --git a/Source/Utilities/LGGOCXXAddress.cpp b/Source/Utilities/LGGOCXXAddress.cpp index 84a7697..1a71695 100644 --- a/Source/Utilities/LGGOCXXAddress.cpp +++ b/Source/Utilities/LGGOCXXAddress.cpp @@ -54,7 +54,7 @@ #pragma mark - #pragma mark Control Block Implementation -LGGOCXXAddress::LGGOCXXAddress(const LGGOCXXSharedStoreContext& C, const LGGOCXXSharedType &T) +LGGOCXXAddress::LGGOCXXAddress(const LGGOCXXSharedStoreContext& C, LGGOCXXType *T) : context(C), strongRefCount(0), weakRefCount(0), type(T) { //Weak declare this weakAddr at top of scope to guarantee the addr is not deleted during setup LGGOCXXWeakAddress weakAddr(this); @@ -65,7 +65,7 @@ LGGOCXXAddress::LGGOCXXAddress(const LGGOCXXSharedStoreContext& C, const LGGOCXX assert(type->getAddress().getAddressValue() == address); } -LGGOCXXAddress::LGGOCXXAddress(const LGGOCXXSharedStoreContext& C, const LGGOCXXSharedType &T, uint64_t A) +LGGOCXXAddress::LGGOCXXAddress(const LGGOCXXSharedStoreContext& C, LGGOCXXType *T, uint64_t A) : context(C), strongRefCount(0), weakRefCount(0), type(T), address(A) { //Weak declare this weakAddr at top of scope to guarantee the addr is not deleted during setup LGGOCXXWeakAddress weakAddr(this); @@ -180,7 +180,7 @@ LGGOCXXSharedAddress::LGGOCXXSharedAddress(const LGGOCXXSharedStoreContext& C, u //printf("Create 0x%llx strong address\n", address->getAddressValue()); } -LGGOCXXSharedAddress::LGGOCXXSharedAddress(const LGGOCXXSharedStoreContext& C, const LGGOCXXSharedType &T) { +LGGOCXXSharedAddress::LGGOCXXSharedAddress(const LGGOCXXSharedStoreContext& C, LGGOCXXType *T) { uint64_t tagValue = T->getTagValue(); if (tagValue) { @@ -215,12 +215,12 @@ uint64_t LGGOCXXSharedAddress::getAddressValue(void) { return address->getAddressValue(); } -LGGOCXXSharedType LGGOCXXSharedAddress::getType (void) { +LGGOCXXType *LGGOCXXSharedAddress::getType (void) { assert(address != NULL); return address->getType(); } -void LGGOCXXSharedAddress::setType (const LGGOCXXSharedType& T) { +void LGGOCXXSharedAddress::setType (LGGOCXXType *T) { assert(address != NULL); address->setType(T); } @@ -229,12 +229,12 @@ bool LGGOCXXSharedAddress::isValid (void) { return (address != NULL); } -LGGOCXXSharedType LGGOCXXSharedAddress::operator* (void) const { +LGGOCXXType *LGGOCXXSharedAddress::operator* (void) const { assert(address != NULL); return address->getType(); } -LGGOCXXSharedType LGGOCXXSharedAddress::operator-> (void) const { +LGGOCXXType *LGGOCXXSharedAddress::operator-> (void) const { assert(address != NULL); return address->getType(); } diff --git a/Source/Utilities/LGGOCXXAddress.h b/Source/Utilities/LGGOCXXAddress.h index 24d0895..922270b 100644 --- a/Source/Utilities/LGGOCXXAddress.h +++ b/Source/Utilities/LGGOCXXAddress.h @@ -49,12 +49,12 @@ class LGGOCXXAddress { private: uint64_t address; LGGOCXXSharedStoreContext context; - LGGOCXXSharedType type; + LGGOCXXType *type; uint32_t strongRefCount; uint32_t weakRefCount; public: - explicit LGGOCXXAddress(const LGGOCXXSharedStoreContext& C, const LGGOCXXSharedType &T, uint64_t A); - explicit LGGOCXXAddress(const LGGOCXXSharedStoreContext& C, const LGGOCXXSharedType &T); + explicit LGGOCXXAddress(const LGGOCXXSharedStoreContext& C, LGGOCXXType *T, uint64_t A); + explicit LGGOCXXAddress(const LGGOCXXSharedStoreContext& C, LGGOCXXType *T); const uint64_t getAddressValue (void); const LGGOSimpleType getType (void) const; @@ -75,11 +75,11 @@ class LGGOCXXAddress { bool operator> (const LGGOCXXAddress& b) const; bool operator< (const LGGOCXXAddress& b) const; - LGGOCXXSharedType getType (void) { + LGGOCXXType * getType (void) { return type; } - void setType (const LGGOCXXSharedType& T) { + void setType (LGGOCXXType *T) { type = T; } @@ -94,20 +94,20 @@ class LGGOCXXSharedAddress { explicit LGGOCXXSharedAddress(const LGGOCXXWeakAddress& A); LGGOCXXSharedAddress(const LGGOCXXSharedAddress& A); LGGOCXXSharedAddress(const LGGOCXXSharedStoreContext& C, uint64_t A); - LGGOCXXSharedAddress(const LGGOCXXSharedStoreContext& C, const LGGOCXXSharedType &T); + LGGOCXXSharedAddress(const LGGOCXXSharedStoreContext& C, LGGOCXXType *T); LGGOCXXSharedAddress(void); ~LGGOCXXSharedAddress(void); const LGGOCXXSharedStoreContext& getContext(void); uint64_t getAddressValue(void); - LGGOCXXSharedType getType (void); + LGGOCXXType * getType (void); - void setType (const LGGOCXXSharedType& T); + void setType (LGGOCXXType *T); bool isValid (void); - LGGOCXXSharedType operator* (void) const; - LGGOCXXSharedType operator-> (void) const; + LGGOCXXType * operator* (void) const; + LGGOCXXType * operator-> (void) const; LGGOCXXSharedAddress& operator= (const LGGOCXXSharedAddress& A); diff --git a/Source/objc/LGGOClass.mm b/Source/objc/LGGOClass.mm index 07b93a8..91ab7af 100644 --- a/Source/objc/LGGOClass.mm +++ b/Source/objc/LGGOClass.mm @@ -54,8 +54,7 @@ - (id) initWithName:(NSString *)name_ inContext:(LGGOGraphContext *)context_ { self = [super init]; if (self) { - LGGOCXXSharedType type(new LGGOCXXClass(std::string(name_.UTF8String))); - address = LGGOCXXSharedAddress(context_.CXXContext, type); + address = LGGOCXXSharedAddress(context_.CXXContext, new LGGOCXXClass(std::string(name_.UTF8String))); graphContext = [context_ retain]; address->setNativeObject(self); } diff --git a/Source/objc/LGGOGraphContext.mm b/Source/objc/LGGOGraphContext.mm index 5067630..1fee4ee 100644 --- a/Source/objc/LGGOGraphContext.mm +++ b/Source/objc/LGGOGraphContext.mm @@ -69,18 +69,18 @@ - (id) transmuteToNativeObject:(LGGOCXXSharedAddress)address { id retval = (id)(*address)->getNativeObject(); if (!retval) { - std::tr1::shared_ptr lggoArray = std::tr1::dynamic_pointer_cast(*address); - if (lggoArray.get()) { + LGGOCXXHackArray *lggoArray = dynamic_cast(*address); + if (lggoArray) { return [[[LGGOMutableArray alloc] initWithGraphObject:address inContext:self] autorelease]; } - std::tr1::shared_ptr lggoString = std::tr1::dynamic_pointer_cast(*address); - if (lggoString.get()) { + LGGOCXXString *lggoString = dynamic_cast(*address); + if (lggoString) { return [[[LGGOString alloc] initWithGraphObject:address inContext:self] autorelease]; } - std::tr1::shared_ptr lggoNumber = std::tr1::dynamic_pointer_cast(*address); - if (lggoNumber.get()) { + LGGOCXXNumber *lggoNumber = dynamic_cast(*address); + if (lggoNumber) { return [[[LGGONumber alloc] initWithGraphObject:address inContext:self] autorelease]; } } @@ -97,18 +97,18 @@ - (LGGOCXXSharedAddress) transmuteToGraphObject:(id)object { retval->setNativeObject(object); } else if ([object isKindOfClass:[NSString class]]) { NSString *string = object; - retval = LGGOCXXSharedAddress(self.CXXContext, LGGOCXXSharedType(new LGGOCXXString(string.UTF8String))); + retval = LGGOCXXSharedAddress(self.CXXContext, new LGGOCXXString(string.UTF8String)); retval->setNativeObject(object); } else if ([object isKindOfClass:[NSNumber class]]) { //FIXME this needs improvement for floats NSNumber *number = object; - LGGOCXXSharedAddress temp(self.CXXContext, LGGOCXXSharedType(new LGGOCXXNumber(number.longLongValue))); + LGGOCXXSharedAddress temp(self.CXXContext, new LGGOCXXNumber(number.longLongValue)); retval = temp; retval->setNativeObject(object); } else if ([object isKindOfClass:[NSArray class]]) { NSArray *array = object; - retval = LGGOCXXSharedAddress(self.CXXContext, LGGOCXXSharedType(new LGGOCXXHackArray())); - std::tr1::shared_ptr lggoArray = std::tr1::dynamic_pointer_cast(*retval); + retval = LGGOCXXSharedAddress(self.CXXContext, new LGGOCXXHackArray()); + LGGOCXXHackArray *lggoArray = dynamic_cast(*retval); [array enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) { lggoArray->addObject([self transmuteToGraphObject:obj]); }]; diff --git a/Source/objc/LGGOMutableArray.mm b/Source/objc/LGGOMutableArray.mm index aa791c9..8f10317 100644 --- a/Source/objc/LGGOMutableArray.mm +++ b/Source/objc/LGGOMutableArray.mm @@ -60,8 +60,7 @@ - (id)initInContext:(LGGOGraphContext *)context_ { self = [super init]; if (self) { - LGGOCXXSharedType type(new LGGOCXXHackArray()); - address = LGGOCXXSharedAddress(context_.CXXContext, type); + address = LGGOCXXSharedAddress(context_.CXXContext, new LGGOCXXHackArray()); graphContext = [context_ retain]; address->setNativeObject(self); } @@ -79,12 +78,11 @@ - (void)dealloc { } - (NSUInteger)count { - NSUInteger retval = std::tr1::dynamic_pointer_cast(*address)->getCount(); - return retval; + return dynamic_cast(*address)->getCount(); } - (id)objectAtIndex:(NSUInteger)index { - LGGOCXXSharedAddress typedObject = std::tr1::dynamic_pointer_cast(*address)->getObjectAtIndex(index); + LGGOCXXSharedAddress typedObject = dynamic_cast(*address)->getObjectAtIndex(index); id retval = (id)typedObject->getNativeObject(); if (!retval) { @@ -97,27 +95,27 @@ - (id)objectAtIndex:(NSUInteger)index { - (void)addObject:(id)anObject { LGGOCXXSharedAddress objectAddress = [graphContext transmuteToGraphObject:anObject]; - std::tr1::dynamic_pointer_cast(*address)->addObject(objectAddress); + dynamic_cast(*address)->addObject(objectAddress); } - (void)insertObject:(id)anObject atIndex:(NSUInteger)index { LGGOCXXSharedAddress objectAddress = [graphContext transmuteToGraphObject:anObject]; - std::tr1::dynamic_pointer_cast(*address)->insertObjectAtIndex(objectAddress, index); + dynamic_cast(*address)->insertObjectAtIndex(objectAddress, index); } - (void)removeLastObject { - std::tr1::dynamic_pointer_cast(*address)->removeLastObject(); + dynamic_cast(*address)->removeLastObject(); } - (void)removeObjectAtIndex:(NSUInteger)index { - std::tr1::dynamic_pointer_cast(*address)->removeObjectAtIndex(index); + dynamic_cast(*address)->removeObjectAtIndex(index); } - (void)replaceObjectAtIndex:(NSUInteger)index withObject:(id)anObject { LGGOCXXSharedAddress objectAddress = [graphContext transmuteToGraphObject:anObject]; - std::tr1::dynamic_pointer_cast(*address)->replaceObjectAtIndexWithObject(objectAddress, index); + dynamic_cast(*address)->replaceObjectAtIndexWithObject(objectAddress, index); } @end diff --git a/Source/objc/LGGONumber.mm b/Source/objc/LGGONumber.mm index 9522d71..4c9defe 100644 --- a/Source/objc/LGGONumber.mm +++ b/Source/objc/LGGONumber.mm @@ -67,8 +67,7 @@ - (id)initWithNumber:(NSNumber *)number_ inContext:(LGGOGraphContext *)context_ id retval; if (self) { - LGGOCXXSharedType type(new LGGOCXXNumber(number_.longLongValue)); - address = LGGOCXXSharedAddress(context_.CXXContext, type); + address = LGGOCXXSharedAddress(context_.CXXContext, new LGGOCXXNumber(number_.longLongValue)); id existingObject = (id)address->getNativeObject(); @@ -97,7 +96,7 @@ - (void) dealloc { } - (void)getValue:(void *)value_ { - std::tr1::shared_ptr sharedNumber = std::tr1::dynamic_pointer_cast(*address); + LGGOCXXNumber *sharedNumber = dynamic_cast(*address); switch(sharedNumber->getType()) { case kLGGOCXX8BitSignedNumberType: case kLGGOCXX16BitSignedNumberType: @@ -118,22 +117,22 @@ - (void)getValue:(void *)value_ { } } -#define LGGO_NUMBER_ACCESSOR(datatype, name) \ -- (datatype)name { \ - std::tr1::shared_ptr sharedNumber = std::tr1::dynamic_pointer_cast(*address); \ - datatype retval; \ - switch(sharedNumber->getType()) { \ - case kLGGOCXX8BitSignedNumberType : \ - case kLGGOCXX16BitSignedNumberType : \ - case kLGGOCXX32BitSignedNumberType : \ - case kLGGOCXX64BitSignedNumberType : retval = sharedNumber->signedValue(); break; \ - case kLGGOCXX8BitUnsignedNumberType : \ - case kLGGOCXX16BitUnsignedNumberType : \ - case kLGGOCXX32BitUnsignedNumberType : \ - case kLGGOCXX64BitUnsignedNumberType : retval = sharedNumber->unsignedValue(); break; \ - default: assert(0); break; \ - } \ - return retval; \ +#define LGGO_NUMBER_ACCESSOR(datatype, name) \ +- (datatype)name { \ + LGGOCXXNumber *sharedNumber = dynamic_cast(*address); \ + datatype retval; \ + switch(sharedNumber->getType()) { \ + case kLGGOCXX8BitSignedNumberType : \ + case kLGGOCXX16BitSignedNumberType : \ + case kLGGOCXX32BitSignedNumberType : \ + case kLGGOCXX64BitSignedNumberType : retval = sharedNumber->signedValue(); break; \ + case kLGGOCXX8BitUnsignedNumberType : \ + case kLGGOCXX16BitUnsignedNumberType : \ + case kLGGOCXX32BitUnsignedNumberType : \ + case kLGGOCXX64BitUnsignedNumberType : retval = sharedNumber->unsignedValue(); break; \ + default: assert(0); break; \ + } \ + return retval; \ } LGGO_NUMBER_ACCESSOR(char, charValue) @@ -156,7 +155,7 @@ - (datatype)name { - (const char *)objCType { const char *retval; - switch(std::tr1::dynamic_pointer_cast(*address)->getType()) { + switch(dynamic_cast(*address)->getType()) { case kLGGOCXX8BitSignedNumberType : retval = "c"; break; case kLGGOCXX8BitUnsignedNumberType : retval = "C"; break; case kLGGOCXX16BitSignedNumberType : retval = "i"; break; diff --git a/Source/objc/LGGOString.mm b/Source/objc/LGGOString.mm index e4f81fd..bec624a 100644 --- a/Source/objc/LGGOString.mm +++ b/Source/objc/LGGOString.mm @@ -64,8 +64,7 @@ - (id)initWithString:(NSString *)string_ inContext:(LGGOGraphContext *)context_ id retval; if (self) { - LGGOCXXSharedType type(new LGGOCXXString(std::string(string_.UTF8String))); - address = LGGOCXXSharedAddress(context_.CXXContext, type); + address = LGGOCXXSharedAddress(context_.CXXContext, new LGGOCXXString(std::string(string_.UTF8String))); id existingObject = (id)address->getNativeObject(); @@ -92,14 +91,12 @@ - (void) dealloc { [super dealloc]; } -- (NSUInteger)length { - NSUInteger retval = std::tr1::dynamic_pointer_cast(*address)->getLength(); - - return retval; +- (NSUInteger)length { + return dynamic_cast(*address)->getLength(); } - (unichar)characterAtIndex:(NSUInteger)index { - return std::tr1::dynamic_pointer_cast(*address)->getCharacterAtIndex(index); + return dynamic_cast(*address)->getCharacterAtIndex(index); } #if 0 From 6a000eace06e7a34d393eaadd8fb30ccb2719187 Mon Sep 17 00:00:00 2001 From: Louis Gerbarg Date: Tue, 9 Nov 2010 15:41:14 -0800 Subject: [PATCH 5/9] Remove vestigial support for graph objects retaining native objects --- Source/Storage/LGGOCXXStoreContext.cpp | 22 +--------------------- Source/Storage/LGGOCXXStoreContext.h | 8 -------- Source/objc/LGGOGraphContext.mm | 6 +++--- 3 files changed, 4 insertions(+), 32 deletions(-) diff --git a/Source/Storage/LGGOCXXStoreContext.cpp b/Source/Storage/LGGOCXXStoreContext.cpp index f769788..b591436 100644 --- a/Source/Storage/LGGOCXXStoreContext.cpp +++ b/Source/Storage/LGGOCXXStoreContext.cpp @@ -34,7 +34,7 @@ #include "LGGOCXXStoreContext.h" LGGOCXXStoreContext::LGGOCXXStoreContext(const LGGOCXXSharedStore &S) - : store(S), nextAddressValue(256), nativeRetainFunc(NULL), nativeReleaseFunc(NULL) { + : store(S), nextAddressValue(256) { } uint64_t LGGOCXXStoreContext::getNextFreeAddress (void) { @@ -43,26 +43,6 @@ uint64_t LGGOCXXStoreContext::getNextFreeAddress (void) { return retval; } -void LGGOCXXStoreContext::setNativeObjectRetain(void (*NRF)(void *)) { - nativeRetainFunc = NRF; -} - -void LGGOCXXStoreContext::setNativeObjectRelease(void (*NRF)(void *)) { - nativeReleaseFunc = NRF; -} - -void LGGOCXXStoreContext::nativeObjectRetain(void *nativeObject) { - if (nativeRetainFunc) { - nativeRetainFunc(nativeObject); - } -} - -void LGGOCXXStoreContext::nativeObjectRelease(void *nativeObject) { - if (nativeReleaseFunc) { - nativeReleaseFunc(nativeObject); - } -} - //FIXME implement transient save here void LGGOCXXStoreContext::writeSegment (void) { diff --git a/Source/Storage/LGGOCXXStoreContext.h b/Source/Storage/LGGOCXXStoreContext.h index 3f8f872..c63e414 100644 --- a/Source/Storage/LGGOCXXStoreContext.h +++ b/Source/Storage/LGGOCXXStoreContext.h @@ -50,8 +50,6 @@ class LGGOCXXStoreContext : public std::tr1::enable_shared_from_this segments; uint64_t nextAddressValue; - void (*nativeReleaseFunc)(void *); - void (*nativeRetainFunc)(void *); std::map addresses; //FIXME this should be weak, but without native types that can bump shared_ptrs it needs to be strong for now @@ -64,12 +62,6 @@ class LGGOCXXStoreContext : public std::tr1::enable_shared_from_thissetNativeObjectRetain((void (*)(void *))&CFRetain); - CXXContext->setNativeObjectRelease((void (*)(void *))&CFRelease); } return self; From be6c6bd162977c50e737366c42321a82339a835a Mon Sep 17 00:00:00 2001 From: Louis Gerbarg Date: Tue, 9 Nov 2010 15:45:29 -0800 Subject: [PATCH 6/9] Added Github repo link to README --- README.md | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 74fadfd..da35259 100644 --- a/README.md +++ b/README.md @@ -7,10 +7,11 @@ GraphObjects is intended to work on Mac OS X 10.6+ and iOS 4.2+. The underlying __Building__ GraphObjects requires a clang 2.0 toolchain in order to build. that mean that no currently released build of Xcode can build it out of box. In order to build it you either need to build a a custom MacOS X 10.6 or iOS 4.2 SDK using a copy of clang pulled from their repository, hack up your system compilers, or use unreleased developer tool previews. While GraphObjects has occasionally been built for iOS, it currently is being primarily brought up on Mac OS X x86. - + __Usage__ You probably don't want to use this yet unless you are intending to hack on it. It's API is similiar to CoreData, though there is no modeler (it derives object info directly from LGGOObjects). The only header files that should be considered public to framework clients are LGGOGraph.h and LGGOGraphContext.h, and even those currently leak some private details. -Mailing List: [http://groups.google.com/group/graphobjects](http://groups.google.com/group/graphobjects) -Contributor Agreement: [https://github.com/GLsoft/GraphObjects/raw/master/GCA.pdf](https://github.com/GLsoft/GraphObjects/raw/master/GCA.pdf) +* Mailing List: [http://groups.google.com/group/graphobjects](http://groups.google.com/group/graphobjects) +* Contributor Agreement: [https://github.com/GLsoft/GraphObjects/raw/master/GCA.pdf](https://github.com/GLsoft/GraphObjects/raw/master/GCA.pdf) +* Github repo: [https://github.com/GLsoft/GraphObjects](https://github.com/GLsoft/GraphObjects) \ No newline at end of file From 35477319806ad1aec16c49631c1178088d18136a Mon Sep 17 00:00:00 2001 From: Louis Gerbarg Date: Wed, 10 Nov 2010 02:48:41 -0800 Subject: [PATCH 7/9] Moved dirty and dusty out of types, into address --- Source/Types/LGGOCXXClass.cpp | 10 +---- Source/Types/LGGOCXXClass.h | 2 - Source/Types/LGGOCXXNumber.cpp | 10 +---- Source/Types/LGGOCXXNumber.h | 2 - Source/Types/LGGOCXXString.cpp | 11 +----- Source/Types/LGGOCXXString.h | 2 - Source/Types/LGGOCXXType.h | 2 - Source/Utilities/LGGOCXXAddress.cpp | 59 ++++++++++++++++++++++++++++- Source/Utilities/LGGOCXXAddress.h | 29 ++++++++++---- 9 files changed, 82 insertions(+), 45 deletions(-) diff --git a/Source/Types/LGGOCXXClass.cpp b/Source/Types/LGGOCXXClass.cpp index 377afcb..961d2d6 100644 --- a/Source/Types/LGGOCXXClass.cpp +++ b/Source/Types/LGGOCXXClass.cpp @@ -23,7 +23,7 @@ #include "LGGOCXXClass.h" -LGGOCXXClass::LGGOCXXClass(std::string N) : LGGOCXXType(), name(N), dirty(true) { +LGGOCXXClass::LGGOCXXClass(std::string N) : LGGOCXXType(), name(N) { } @@ -124,12 +124,4 @@ uint64_t LGGOCXXClass::getTagValue (void) { LGGOCXXSharedMemoryDescriptor LGGOCXXClass::getSerializedData (void) { return NULL_DESCRIPTOR; -} - -bool LGGOCXXClass::isDusty (void) { - return false; -} - -bool LGGOCXXClass::isDirty (void) { - return dirty; } \ No newline at end of file diff --git a/Source/Types/LGGOCXXClass.h b/Source/Types/LGGOCXXClass.h index d46aa96..bcc27c3 100644 --- a/Source/Types/LGGOCXXClass.h +++ b/Source/Types/LGGOCXXClass.h @@ -54,8 +54,6 @@ class LGGOCXXClass : public LGGOCXXType { virtual uint64_t getTagValue (void); virtual LGGOCXXSharedMemoryDescriptor getSerializedData (void); - virtual bool isDirty(void); - virtual bool isDusty(void); }; #endif \ No newline at end of file diff --git a/Source/Types/LGGOCXXNumber.cpp b/Source/Types/LGGOCXXNumber.cpp index 3909839..1ca6253 100644 --- a/Source/Types/LGGOCXXNumber.cpp +++ b/Source/Types/LGGOCXXNumber.cpp @@ -27,7 +27,7 @@ #define LGGO_MAX_INT59 ((int64_t)0x03ffffffffffffff) #define LGGO_MIN_INT59 ((int64_t)(-1*LGGO_MAX_INT59)) -LGGOCXXNumber::LGGOCXXNumber(int64_t N) : LGGOCXXType(), dirty(true), rawValue(N) { +LGGOCXXNumber::LGGOCXXNumber(int64_t N) : LGGOCXXType(), rawValue(N) { rawValue = *((uint64_t *)&N); if (N >= 0) { @@ -88,14 +88,6 @@ LGGOCXXSharedMemoryDescriptor LGGOCXXNumber::getSerializedData(void) { return NULL_DESCRIPTOR; } -bool LGGOCXXNumber::isDirty(void) { - return dirty; -} - -bool LGGOCXXNumber::isDusty(void) { - return false; -} - int64_t LGGOCXXNumber::signedValue (void) { return *((int64_t *)&rawValue); } diff --git a/Source/Types/LGGOCXXNumber.h b/Source/Types/LGGOCXXNumber.h index 880d536..e06578b 100644 --- a/Source/Types/LGGOCXXNumber.h +++ b/Source/Types/LGGOCXXNumber.h @@ -57,8 +57,6 @@ class LGGOCXXNumber : public LGGOCXXType { virtual uint64_t getTagValue (void); virtual LGGOCXXSharedMemoryDescriptor getSerializedData (void); - virtual bool isDirty(void); - virtual bool isDusty(void); }; #endif \ No newline at end of file diff --git a/Source/Types/LGGOCXXString.cpp b/Source/Types/LGGOCXXString.cpp index f172759..0dc6725 100644 --- a/Source/Types/LGGOCXXString.cpp +++ b/Source/Types/LGGOCXXString.cpp @@ -28,7 +28,7 @@ #include "utf8.h" LGGOCXXString::LGGOCXXString(std::string S) - : LGGOCXXType(), charLength(0), lengthCalculated(false), dirty(true) { + : LGGOCXXType(), charLength(0), lengthCalculated(false) { byteLength = S.size(); if(byteLength <= 7) { @@ -62,15 +62,6 @@ uint64_t LGGOCXXString::getTagValue (void) { return retval; } - -bool LGGOCXXString::isDirty(void) { - return dirty; -} - -bool LGGOCXXString::isDusty(void) { - return false; -} - uint32_t LGGOCXXString::getLength(void) { if (lengthCalculated == false) { LGGOCXXCoreMemoryDescriptor::iterator i = stringDescriptor->begin()+1; diff --git a/Source/Types/LGGOCXXString.h b/Source/Types/LGGOCXXString.h index 1b1adee..33e6cd8 100644 --- a/Source/Types/LGGOCXXString.h +++ b/Source/Types/LGGOCXXString.h @@ -54,8 +54,6 @@ class LGGOCXXString : public LGGOCXXType { virtual uint64_t getTagValue (void); virtual LGGOCXXSharedMemoryDescriptor getSerializedData (void); - virtual bool isDirty(void); - virtual bool isDusty(void); }; #endif \ No newline at end of file diff --git a/Source/Types/LGGOCXXType.h b/Source/Types/LGGOCXXType.h index fb429c1..afcd656 100644 --- a/Source/Types/LGGOCXXType.h +++ b/Source/Types/LGGOCXXType.h @@ -83,8 +83,6 @@ class LGGOCXXType { virtual LGGOCXXSharedMemoryDescriptor getSerializedData (void) = 0; virtual uint64_t getTagValue (void) = 0; - virtual bool isDirty(void) = 0; - virtual bool isDusty(void) = 0; }; #endif \ No newline at end of file diff --git a/Source/Utilities/LGGOCXXAddress.cpp b/Source/Utilities/LGGOCXXAddress.cpp index 1a71695..cef8015 100644 --- a/Source/Utilities/LGGOCXXAddress.cpp +++ b/Source/Utilities/LGGOCXXAddress.cpp @@ -55,7 +55,7 @@ #pragma mark Control Block Implementation LGGOCXXAddress::LGGOCXXAddress(const LGGOCXXSharedStoreContext& C, LGGOCXXType *T) - : context(C), strongRefCount(0), weakRefCount(0), type(T) { + : context(C), strongRefCount(0), weakRefCount(0), dirty(false), dusty(false), type(T) { //Weak declare this weakAddr at top of scope to guarantee the addr is not deleted during setup LGGOCXXWeakAddress weakAddr(this); T->setAddress(weakAddr); @@ -66,7 +66,7 @@ LGGOCXXAddress::LGGOCXXAddress(const LGGOCXXSharedStoreContext& C, LGGOCXXType * } LGGOCXXAddress::LGGOCXXAddress(const LGGOCXXSharedStoreContext& C, LGGOCXXType *T, uint64_t A) - : context(C), strongRefCount(0), weakRefCount(0), type(T), address(A) { + : context(C), strongRefCount(0), weakRefCount(0), dirty(false), dusty(false), type(T), address(A) { //Weak declare this weakAddr at top of scope to guarantee the addr is not deleted during setup LGGOCXXWeakAddress weakAddr(this); T->setAddress(weakAddr); @@ -148,6 +148,46 @@ const LGGOCXXSharedStoreContext& LGGOCXXAddress::getContext(void) { return context; } +LGGOCXXType * LGGOCXXAddress::getType (void) { + return type; +} + +void LGGOCXXAddress::setType (LGGOCXXType *T) { + type = T; +} + +bool LGGOCXXAddress::getDirty (void) { + return dirty; +} + +void LGGOCXXAddress::setDirty (bool D) { + dirty = D; +} + +bool LGGOCXXAddress::getDusty (void) { + return dusty; +} + +void LGGOCXXAddress::setDusty (bool D) { + dusty = D; +} + +bool LGGOCXXSharedAddress::getDirty (void) { + return address->getDirty(); +} + +void LGGOCXXSharedAddress::setDirty (bool D) { + address->setDirty(D); +} + +bool LGGOCXXSharedAddress::getDusty (void) { + return address->getDusty(); +} + +void LGGOCXXSharedAddress::setDusty (bool D) { + address->setDusty(D); +} + #pragma mark - #pragma mark Strong Pointer Implementation @@ -307,3 +347,18 @@ LGGOCXXWeakAddress& LGGOCXXWeakAddress::operator= (const LGGOCXXWeakAddress& A) return *this; } +bool LGGOCXXWeakAddress::getDirty (void) { + return address->getDirty(); +} + +void LGGOCXXWeakAddress::setDirty (bool D) { + address->setDirty(D); +} + +bool LGGOCXXWeakAddress::getDusty (void) { + return address->getDusty(); +} + +void LGGOCXXWeakAddress::setDusty (bool D) { + address->setDusty(D); +} diff --git a/Source/Utilities/LGGOCXXAddress.h b/Source/Utilities/LGGOCXXAddress.h index 922270b..e6f1cce 100644 --- a/Source/Utilities/LGGOCXXAddress.h +++ b/Source/Utilities/LGGOCXXAddress.h @@ -52,6 +52,8 @@ class LGGOCXXAddress { LGGOCXXType *type; uint32_t strongRefCount; uint32_t weakRefCount; + bool dirty:1; + bool dusty:1; public: explicit LGGOCXXAddress(const LGGOCXXSharedStoreContext& C, LGGOCXXType *T, uint64_t A); explicit LGGOCXXAddress(const LGGOCXXSharedStoreContext& C, LGGOCXXType *T); @@ -75,18 +77,17 @@ class LGGOCXXAddress { bool operator> (const LGGOCXXAddress& b) const; bool operator< (const LGGOCXXAddress& b) const; - LGGOCXXType * getType (void) { - return type; - } + LGGOCXXType * getType (void); + void setType (LGGOCXXType *T); - void setType (LGGOCXXType *T) { - type = T; - } + bool getDirty (void); + void setDirty (bool D); + bool getDusty (void); + void setDusty (bool D); friend class LGGOCXXSharedAddress; friend class LGGOCXXWeakAddress; }; - class LGGOCXXSharedAddress { private: LGGOCXXAddress *address; @@ -98,6 +99,12 @@ class LGGOCXXSharedAddress { LGGOCXXSharedAddress(void); ~LGGOCXXSharedAddress(void); + bool getDirty (void); + void setDirty (bool D); + bool getDusty (void); + void setDusty (bool D); + + const LGGOCXXSharedStoreContext& getContext(void); uint64_t getAddressValue(void); @@ -123,6 +130,11 @@ class LGGOCXXWeakAddress { explicit LGGOCXXWeakAddress(LGGOCXXAddress *A); LGGOCXXWeakAddress(const LGGOCXXWeakAddress&A); ~LGGOCXXWeakAddress(void); + + bool getDirty (void); + void setDirty (bool D); + bool getDusty (void); + void setDusty (bool D); const LGGOCXXSharedStoreContext& getContext(void); uint64_t getAddressValue(void); @@ -133,4 +145,7 @@ class LGGOCXXWeakAddress { friend class LGGOCXXSharedAddress; }; + + + #endif \ No newline at end of file From 9219d128f736f7224727b27f61f7053b398586d6 Mon Sep 17 00:00:00 2001 From: Louis Gerbarg Date: Thu, 11 Nov 2010 23:16:35 -0800 Subject: [PATCH 8/9] Refactor the various types and references so their naming and creation makes more sense --- GraphObjects.xcodeproj/project.pbxproj | 120 ++++++++--------- Source/Storage/LGGOCXXMemoryDescriptor.h | 2 +- Source/Storage/LGGOCXXStoreContext.cpp | 32 ++--- Source/Storage/LGGOCXXStoreContext.h | 16 +-- Source/Storage/LGGOCXXStoreSegment.cpp | 4 +- Source/Storage/LGGOCXXStoreSegment.h | 4 +- .../HackArray/LGGOCXXHackArray.cpp | 71 ---------- .../HackArray/LGGOCXXHackArrayRef.cpp | 67 ++++++++++ ...GOCXXHackArray.h => LGGOCXXHackArrayRef.h} | 23 ++-- .../{LGGOCXXClass.cpp => LGGOCXXClassRef.cpp} | 28 ++-- .../{LGGOCXXClass.h => LGGOCXXClassRef.h} | 15 ++- ...LGGOCXXNumber.cpp => LGGOCXXNumberRef.cpp} | 22 ++-- .../{LGGOCXXNumber.h => LGGOCXXNumberRef.h} | 15 ++- ...LGGOCXXObject.cpp => LGGOCXXObjectRef.cpp} | 2 +- .../{LGGOCXXObject.h => LGGOCXXObjectRef.h} | 10 +- .../{LGGOCXXType.cpp => LGGOCXXReference.cpp} | 14 +- .../{LGGOCXXType.h => LGGOCXXReference.h} | 32 +++-- .../LGGOCXXReferenceMetadata.cpp} | 122 +++++++++--------- .../LGGOCXXReferenceMetadata.h} | 80 ++++++------ ...LGGOCXXString.cpp => LGGOCXXStringRef.cpp} | 18 ++- .../{LGGOCXXString.h => LGGOCXXStringRef.h} | 13 +- Source/objc/LGGOClass.h | 2 +- Source/objc/LGGOClass.mm | 10 +- Source/objc/LGGOGraphContext.h | 8 +- Source/objc/LGGOGraphContext.mm | 33 +++-- Source/objc/LGGOMutableArray.h | 6 +- Source/objc/LGGOMutableArray.mm | 30 ++--- Source/objc/LGGONumber.h | 2 +- Source/objc/LGGONumber.mm | 22 ++-- Source/objc/LGGOString.h | 2 +- Source/objc/LGGOString.mm | 18 +-- TODO | 2 +- 32 files changed, 429 insertions(+), 416 deletions(-) delete mode 100644 Source/Types/Collections/HackArray/LGGOCXXHackArray.cpp create mode 100644 Source/Types/Collections/HackArray/LGGOCXXHackArrayRef.cpp rename Source/Types/Collections/HackArray/{LGGOCXXHackArray.h => LGGOCXXHackArrayRef.h} (72%) rename Source/Types/{LGGOCXXClass.cpp => LGGOCXXClassRef.cpp} (74%) rename Source/Types/{LGGOCXXClass.h => LGGOCXXClassRef.h} (88%) rename Source/Types/{LGGOCXXNumber.cpp => LGGOCXXNumberRef.cpp} (82%) rename Source/Types/{LGGOCXXNumber.h => LGGOCXXNumberRef.h} (86%) rename Source/Types/{LGGOCXXObject.cpp => LGGOCXXObjectRef.cpp} (97%) rename Source/Types/{LGGOCXXObject.h => LGGOCXXObjectRef.h} (89%) rename Source/Types/{LGGOCXXType.cpp => LGGOCXXReference.cpp} (75%) rename Source/Types/{LGGOCXXType.h => LGGOCXXReference.h} (79%) rename Source/{Utilities/LGGOCXXAddress.cpp => Types/LGGOCXXReferenceMetadata.cpp} (60%) rename Source/{Utilities/LGGOCXXAddress.h => Types/LGGOCXXReferenceMetadata.h} (58%) rename Source/Types/{LGGOCXXString.cpp => LGGOCXXStringRef.cpp} (85%) rename Source/Types/{LGGOCXXString.h => LGGOCXXStringRef.h} (88%) diff --git a/GraphObjects.xcodeproj/project.pbxproj b/GraphObjects.xcodeproj/project.pbxproj index 09f2b81..351093a 100644 --- a/GraphObjects.xcodeproj/project.pbxproj +++ b/GraphObjects.xcodeproj/project.pbxproj @@ -13,8 +13,8 @@ BF0234361280D2F2004390C4 /* LGGOString.h in Headers */ = {isa = PBXBuildFile; fileRef = BF0234321280D2F2004390C4 /* LGGOString.h */; }; BF0234391280D312004390C4 /* LGGOClass.h in Headers */ = {isa = PBXBuildFile; fileRef = BF0234371280D312004390C4 /* LGGOClass.h */; }; BF02343A1280D312004390C4 /* LGGOClass.mm in Sources */ = {isa = PBXBuildFile; fileRef = BF0234381280D312004390C4 /* LGGOClass.mm */; }; - BF232704127E8F5200496AF5 /* LGGOCXXNumber.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BF232702127E8F5200496AF5 /* LGGOCXXNumber.cpp */; }; - BF232705127E8F5200496AF5 /* LGGOCXXNumber.h in Headers */ = {isa = PBXBuildFile; fileRef = BF232703127E8F5200496AF5 /* LGGOCXXNumber.h */; }; + BF232704127E8F5200496AF5 /* LGGOCXXNumberRef.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BF232702127E8F5200496AF5 /* LGGOCXXNumberRef.cpp */; }; + BF232705127E8F5200496AF5 /* LGGOCXXNumberRef.h in Headers */ = {isa = PBXBuildFile; fileRef = BF232703127E8F5200496AF5 /* LGGOCXXNumberRef.h */; }; BF3355471276519600F34934 /* InfoPlist.strings in Resources */ = {isa = PBXBuildFile; fileRef = BF3355451276519600F34934 /* InfoPlist.strings */; }; BF3355881276523900F34934 /* LGGOCXXMemoryDescriptor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BF3355621276523900F34934 /* LGGOCXXMemoryDescriptor.cpp */; }; BF3355891276523900F34934 /* LGGOCXXMemoryDescriptor.h in Headers */ = {isa = PBXBuildFile; fileRef = BF3355631276523900F34934 /* LGGOCXXMemoryDescriptor.h */; }; @@ -26,38 +26,38 @@ BF33558F1276523900F34934 /* LGGOCXXStoreHash.h in Headers */ = {isa = PBXBuildFile; fileRef = BF3355691276523900F34934 /* LGGOCXXStoreHash.h */; }; BF3355901276523900F34934 /* LGGOCXXStoreSegment.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BF33556A1276523900F34934 /* LGGOCXXStoreSegment.cpp */; }; BF3355911276523900F34934 /* LGGOCXXStoreSegment.h in Headers */ = {isa = PBXBuildFile; fileRef = BF33556B1276523900F34934 /* LGGOCXXStoreSegment.h */; }; - BF33559A1276523900F34934 /* LGGOCXXAddress.h in Headers */ = {isa = PBXBuildFile; fileRef = BF3355761276523900F34934 /* LGGOCXXAddress.h */; }; BF33559B1276523900F34934 /* LGGOByteOrder.h in Headers */ = {isa = PBXBuildFile; fileRef = BF3355771276523900F34934 /* LGGOByteOrder.h */; }; BF3355A01276526300F34934 /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = BF33559F1276526300F34934 /* Foundation.framework */; }; BF3355A21276527800F34934 /* libz.1.2.3.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = BF3355A11276527800F34934 /* libz.1.2.3.dylib */; }; - BF532C15127954B90040B280 /* LGGOCXXType.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BF532C13127954B90040B280 /* LGGOCXXType.cpp */; }; - BF532C16127954B90040B280 /* LGGOCXXType.h in Headers */ = {isa = PBXBuildFile; fileRef = BF532C14127954B90040B280 /* LGGOCXXType.h */; }; + BF532C15127954B90040B280 /* LGGOCXXReference.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BF532C13127954B90040B280 /* LGGOCXXReference.cpp */; }; + BF532C16127954B90040B280 /* LGGOCXXReference.h in Headers */ = {isa = PBXBuildFile; fileRef = BF532C14127954B90040B280 /* LGGOCXXReference.h */; }; BF532C1E1279690C0040B280 /* LGGOGraphContext.h in Headers */ = {isa = PBXBuildFile; fileRef = BF532C1C1279690C0040B280 /* LGGOGraphContext.h */; }; BF532C1F1279690C0040B280 /* LGGOGraphContext.mm in Sources */ = {isa = PBXBuildFile; fileRef = BF532C1D1279690C0040B280 /* LGGOGraphContext.mm */; }; BF532C2212796F240040B280 /* LGGOGraph.h in Headers */ = {isa = PBXBuildFile; fileRef = BF532C2012796F240040B280 /* LGGOGraph.h */; }; BF532C2312796F240040B280 /* LGGOGraph.mm in Sources */ = {isa = PBXBuildFile; fileRef = BF532C2112796F240040B280 /* LGGOGraph.mm */; }; BF6637F212765349000B4A8D /* GraphObjects.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = BF33553F1276519600F34934 /* GraphObjects.framework */; }; - BF7C08AA12832CC100BFD1DB /* LGGOCXXAddress.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BF7C08A912832CC100BFD1DB /* LGGOCXXAddress.cpp */; }; + BF8B7F5B128DD72300B39D0A /* LGGOCXXReferenceMetadata.h in Headers */ = {isa = PBXBuildFile; fileRef = BF8B7F59128DD72300B39D0A /* LGGOCXXReferenceMetadata.h */; }; + BF8B7F5C128DD72300B39D0A /* LGGOCXXReferenceMetadata.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BF8B7F5A128DD72300B39D0A /* LGGOCXXReferenceMetadata.cpp */; }; BFA13448127653DA00D13611 /* LGGOArrayTests.m in Sources */ = {isa = PBXBuildFile; fileRef = BFA1343F127653DA00D13611 /* LGGOArrayTests.m */; }; BFA13449127653DA00D13611 /* LGGOGraphTests.m in Sources */ = {isa = PBXBuildFile; fileRef = BFA13441127653DA00D13611 /* LGGOGraphTests.m */; }; BFA1344A127653DA00D13611 /* LGGOCXXStoreSegmentTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = BFA13443127653DA00D13611 /* LGGOCXXStoreSegmentTests.mm */; }; BFA1344B127653DA00D13611 /* LGGONumberTests.m in Sources */ = {isa = PBXBuildFile; fileRef = BFA13445127653DA00D13611 /* LGGONumberTests.m */; }; BFA1344C127653DA00D13611 /* LGGOStringTests.m in Sources */ = {isa = PBXBuildFile; fileRef = BFA13447127653DA00D13611 /* LGGOStringTests.m */; }; - BFA37A1C1280D5CC002A0892 /* LGGOCXXHackArray.h in Headers */ = {isa = PBXBuildFile; fileRef = BFA37A1A1280D5CC002A0892 /* LGGOCXXHackArray.h */; }; - BFA37A1D1280D5CC002A0892 /* LGGOCXXHackArray.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BFA37A1B1280D5CC002A0892 /* LGGOCXXHackArray.cpp */; }; + BFA37A1C1280D5CC002A0892 /* LGGOCXXHackArrayRef.h in Headers */ = {isa = PBXBuildFile; fileRef = BFA37A1A1280D5CC002A0892 /* LGGOCXXHackArrayRef.h */; }; + BFA37A1D1280D5CC002A0892 /* LGGOCXXHackArrayRef.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BFA37A1B1280D5CC002A0892 /* LGGOCXXHackArrayRef.cpp */; }; BFA37A201280D930002A0892 /* LGGOMutableArray.h in Headers */ = {isa = PBXBuildFile; fileRef = BFA37A1E1280D930002A0892 /* LGGOMutableArray.h */; }; BFA37A211280D930002A0892 /* LGGOMutableArray.mm in Sources */ = {isa = PBXBuildFile; fileRef = BFA37A1F1280D930002A0892 /* LGGOMutableArray.mm */; }; - BFA37A241280DC59002A0892 /* LGGOCXXObject.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BFA37A221280DC59002A0892 /* LGGOCXXObject.cpp */; }; - BFA37A251280DC59002A0892 /* LGGOCXXObject.h in Headers */ = {isa = PBXBuildFile; fileRef = BFA37A231280DC59002A0892 /* LGGOCXXObject.h */; }; + BFA37A241280DC59002A0892 /* LGGOCXXObjectRef.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BFA37A221280DC59002A0892 /* LGGOCXXObjectRef.cpp */; }; + BFA37A251280DC59002A0892 /* LGGOCXXObjectRef.h in Headers */ = {isa = PBXBuildFile; fileRef = BFA37A231280DC59002A0892 /* LGGOCXXObjectRef.h */; }; BFAB4AF1127801580062BBB3 /* LGGOCXXStoreContextTests.mm in Sources */ = {isa = PBXBuildFile; fileRef = BFAB4AF0127801580062BBB3 /* LGGOCXXStoreContextTests.mm */; }; BFD68E511278C519004CBBD2 /* checked.h in Headers */ = {isa = PBXBuildFile; fileRef = BFD68E501278C519004CBBD2 /* checked.h */; }; BFD68E531278C52B004CBBD2 /* core.h in Headers */ = {isa = PBXBuildFile; fileRef = BFD68E521278C52B004CBBD2 /* core.h */; }; BFD68E551278C538004CBBD2 /* unchecked.h in Headers */ = {isa = PBXBuildFile; fileRef = BFD68E541278C538004CBBD2 /* unchecked.h */; }; - BFD860D812781F2B00B7B5B3 /* LGGOCXXString.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BFD860D612781F2B00B7B5B3 /* LGGOCXXString.cpp */; }; - BFD860D912781F2B00B7B5B3 /* LGGOCXXString.h in Headers */ = {isa = PBXBuildFile; fileRef = BFD860D712781F2B00B7B5B3 /* LGGOCXXString.h */; }; + BFD860D812781F2B00B7B5B3 /* LGGOCXXStringRef.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BFD860D612781F2B00B7B5B3 /* LGGOCXXStringRef.cpp */; }; + BFD860D912781F2B00B7B5B3 /* LGGOCXXStringRef.h in Headers */ = {isa = PBXBuildFile; fileRef = BFD860D712781F2B00B7B5B3 /* LGGOCXXStringRef.h */; }; BFE3684D127F615200186A53 /* utf8.h in Headers */ = {isa = PBXBuildFile; fileRef = BFE3684C127F615200186A53 /* utf8.h */; }; - BFE36853127FFA7C00186A53 /* LGGOCXXClass.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BFE36851127FFA7C00186A53 /* LGGOCXXClass.cpp */; }; - BFE36854127FFA7C00186A53 /* LGGOCXXClass.h in Headers */ = {isa = PBXBuildFile; fileRef = BFE36852127FFA7C00186A53 /* LGGOCXXClass.h */; }; + BFE36853127FFA7C00186A53 /* LGGOCXXClassRef.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BFE36851127FFA7C00186A53 /* LGGOCXXClassRef.cpp */; }; + BFE36854127FFA7C00186A53 /* LGGOCXXClassRef.h in Headers */ = {isa = PBXBuildFile; fileRef = BFE36852127FFA7C00186A53 /* LGGOCXXClassRef.h */; }; /* End PBXBuildFile section */ /* Begin PBXFileReference section */ @@ -69,8 +69,8 @@ BF0234381280D312004390C4 /* LGGOClass.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = LGGOClass.mm; sourceTree = ""; }; BF05B7341281D289009A129D /* README.md */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = README.md; sourceTree = ""; }; BF05B7351281D289009A129D /* LICENSE */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = LICENSE; sourceTree = ""; }; - BF232702127E8F5200496AF5 /* LGGOCXXNumber.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LGGOCXXNumber.cpp; sourceTree = ""; }; - BF232703127E8F5200496AF5 /* LGGOCXXNumber.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LGGOCXXNumber.h; sourceTree = ""; }; + BF232702127E8F5200496AF5 /* LGGOCXXNumberRef.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; lineEnding = 0; path = LGGOCXXNumberRef.cpp; sourceTree = ""; xcLanguageSpecificationIdentifier = xcode.lang.cpp; }; + BF232703127E8F5200496AF5 /* LGGOCXXNumberRef.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = LGGOCXXNumberRef.h; sourceTree = ""; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; }; BF33553F1276519600F34934 /* GraphObjects.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = GraphObjects.framework; sourceTree = BUILT_PRODUCTS_DIR; }; BF3355431276519600F34934 /* GraphObjects-Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = "GraphObjects-Info.plist"; sourceTree = ""; }; BF3355441276519600F34934 /* GraphObjects_Prefix.pch */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = GraphObjects_Prefix.pch; sourceTree = ""; }; @@ -79,26 +79,26 @@ BF3355631276523900F34934 /* LGGOCXXMemoryDescriptor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LGGOCXXMemoryDescriptor.h; sourceTree = ""; }; BF3355641276523900F34934 /* LGGOCXXStore.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LGGOCXXStore.cpp; sourceTree = ""; }; BF3355651276523900F34934 /* LGGOCXXStore.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LGGOCXXStore.h; sourceTree = ""; }; - BF3355661276523900F34934 /* LGGOCXXStoreContext.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LGGOCXXStoreContext.cpp; sourceTree = ""; }; - BF3355671276523900F34934 /* LGGOCXXStoreContext.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LGGOCXXStoreContext.h; sourceTree = ""; }; + BF3355661276523900F34934 /* LGGOCXXStoreContext.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; lineEnding = 0; path = LGGOCXXStoreContext.cpp; sourceTree = ""; xcLanguageSpecificationIdentifier = xcode.lang.cpp; }; + BF3355671276523900F34934 /* LGGOCXXStoreContext.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = LGGOCXXStoreContext.h; sourceTree = ""; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; }; BF3355681276523900F34934 /* LGGOCXXStoreHash.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LGGOCXXStoreHash.cpp; sourceTree = ""; }; BF3355691276523900F34934 /* LGGOCXXStoreHash.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LGGOCXXStoreHash.h; sourceTree = ""; }; BF33556A1276523900F34934 /* LGGOCXXStoreSegment.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LGGOCXXStoreSegment.cpp; sourceTree = ""; }; BF33556B1276523900F34934 /* LGGOCXXStoreSegment.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LGGOCXXStoreSegment.h; sourceTree = ""; }; - BF3355761276523900F34934 /* LGGOCXXAddress.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LGGOCXXAddress.h; sourceTree = ""; }; BF3355771276523900F34934 /* LGGOByteOrder.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LGGOByteOrder.h; sourceTree = ""; }; BF33559F1276526300F34934 /* Foundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Foundation.framework; path = System/Library/Frameworks/Foundation.framework; sourceTree = SDKROOT; }; BF3355A11276527800F34934 /* libz.1.2.3.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = libz.1.2.3.dylib; path = usr/lib/libz.1.2.3.dylib; sourceTree = SDKROOT; }; BF42AAA81281CBF600FFCCB9 /* TODO */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = TODO; sourceTree = ""; }; - BF532C13127954B90040B280 /* LGGOCXXType.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LGGOCXXType.cpp; sourceTree = ""; }; - BF532C14127954B90040B280 /* LGGOCXXType.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LGGOCXXType.h; sourceTree = ""; }; - BF532C1C1279690C0040B280 /* LGGOGraphContext.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LGGOGraphContext.h; sourceTree = ""; }; + BF532C13127954B90040B280 /* LGGOCXXReference.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; lineEnding = 0; path = LGGOCXXReference.cpp; sourceTree = ""; xcLanguageSpecificationIdentifier = xcode.lang.cpp; }; + BF532C14127954B90040B280 /* LGGOCXXReference.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = LGGOCXXReference.h; sourceTree = ""; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; }; + BF532C1C1279690C0040B280 /* LGGOGraphContext.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = LGGOGraphContext.h; sourceTree = ""; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; }; BF532C1D1279690C0040B280 /* LGGOGraphContext.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = LGGOGraphContext.mm; sourceTree = ""; }; BF532C2012796F240040B280 /* LGGOGraph.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LGGOGraph.h; sourceTree = ""; }; BF532C2112796F240040B280 /* LGGOGraph.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = LGGOGraph.mm; sourceTree = ""; }; BF6637E91276532E000B4A8D /* GraphObjectsTests.octest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = GraphObjectsTests.octest; sourceTree = BUILT_PRODUCTS_DIR; }; BF6637EA1276532E000B4A8D /* GraphObjectsTests-Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = "GraphObjectsTests-Info.plist"; sourceTree = ""; }; - BF7C08A912832CC100BFD1DB /* LGGOCXXAddress.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LGGOCXXAddress.cpp; sourceTree = ""; }; + BF8B7F59128DD72300B39D0A /* LGGOCXXReferenceMetadata.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LGGOCXXReferenceMetadata.h; sourceTree = ""; }; + BF8B7F5A128DD72300B39D0A /* LGGOCXXReferenceMetadata.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LGGOCXXReferenceMetadata.cpp; sourceTree = ""; }; BFA1343E127653DA00D13611 /* LGGOArrayTests.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LGGOArrayTests.h; sourceTree = ""; }; BFA1343F127653DA00D13611 /* LGGOArrayTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = LGGOArrayTests.m; sourceTree = ""; }; BFA13440127653DA00D13611 /* LGGOGraphTests.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LGGOGraphTests.h; sourceTree = ""; }; @@ -109,23 +109,23 @@ BFA13445127653DA00D13611 /* LGGONumberTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = LGGONumberTests.m; sourceTree = ""; }; BFA13446127653DA00D13611 /* LGGOStringTests.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LGGOStringTests.h; sourceTree = ""; }; BFA13447127653DA00D13611 /* LGGOStringTests.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = LGGOStringTests.m; sourceTree = ""; }; - BFA37A1A1280D5CC002A0892 /* LGGOCXXHackArray.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = LGGOCXXHackArray.h; path = Source/Types/Collections/HackArray/LGGOCXXHackArray.h; sourceTree = SOURCE_ROOT; }; - BFA37A1B1280D5CC002A0892 /* LGGOCXXHackArray.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = LGGOCXXHackArray.cpp; path = Source/Types/Collections/HackArray/LGGOCXXHackArray.cpp; sourceTree = SOURCE_ROOT; }; - BFA37A1E1280D930002A0892 /* LGGOMutableArray.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LGGOMutableArray.h; sourceTree = ""; }; + BFA37A1A1280D5CC002A0892 /* LGGOCXXHackArrayRef.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; name = LGGOCXXHackArrayRef.h; path = Source/Types/Collections/HackArray/LGGOCXXHackArrayRef.h; sourceTree = SOURCE_ROOT; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; }; + BFA37A1B1280D5CC002A0892 /* LGGOCXXHackArrayRef.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = LGGOCXXHackArrayRef.cpp; path = Source/Types/Collections/HackArray/LGGOCXXHackArrayRef.cpp; sourceTree = SOURCE_ROOT; }; + BFA37A1E1280D930002A0892 /* LGGOMutableArray.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = LGGOMutableArray.h; sourceTree = ""; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; }; BFA37A1F1280D930002A0892 /* LGGOMutableArray.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = LGGOMutableArray.mm; sourceTree = ""; }; - BFA37A221280DC59002A0892 /* LGGOCXXObject.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LGGOCXXObject.cpp; sourceTree = ""; }; - BFA37A231280DC59002A0892 /* LGGOCXXObject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LGGOCXXObject.h; sourceTree = ""; }; + BFA37A221280DC59002A0892 /* LGGOCXXObjectRef.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LGGOCXXObjectRef.cpp; sourceTree = ""; }; + BFA37A231280DC59002A0892 /* LGGOCXXObjectRef.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = LGGOCXXObjectRef.h; sourceTree = ""; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; }; BFAB4AEF127801580062BBB3 /* LGGOCXXStoreContextTests.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LGGOCXXStoreContextTests.h; sourceTree = ""; }; BFAB4AF0127801580062BBB3 /* LGGOCXXStoreContextTests.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = LGGOCXXStoreContextTests.mm; sourceTree = ""; }; BFCB88BC1281EB0A00F47C04 /* GCA.pdf */ = {isa = PBXFileReference; lastKnownFileType = image.pdf; path = GCA.pdf; sourceTree = ""; }; BFD68E501278C519004CBBD2 /* checked.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = checked.h; path = /Users/louis/Downloads/utf8_v2_3/source/utf8/checked.h; sourceTree = ""; }; BFD68E521278C52B004CBBD2 /* core.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = core.h; path = /Users/louis/Downloads/utf8_v2_3/source/utf8/core.h; sourceTree = ""; }; BFD68E541278C538004CBBD2 /* unchecked.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = unchecked.h; path = /Users/louis/Downloads/utf8_v2_3/source/utf8/unchecked.h; sourceTree = ""; }; - BFD860D612781F2B00B7B5B3 /* LGGOCXXString.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LGGOCXXString.cpp; sourceTree = ""; }; - BFD860D712781F2B00B7B5B3 /* LGGOCXXString.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LGGOCXXString.h; sourceTree = ""; }; + BFD860D612781F2B00B7B5B3 /* LGGOCXXStringRef.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; lineEnding = 0; path = LGGOCXXStringRef.cpp; sourceTree = ""; xcLanguageSpecificationIdentifier = xcode.lang.cpp; }; + BFD860D712781F2B00B7B5B3 /* LGGOCXXStringRef.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = LGGOCXXStringRef.h; sourceTree = ""; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; }; BFE3684C127F615200186A53 /* utf8.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = utf8.h; path = unicode/utf8.h; sourceTree = ""; }; - BFE36851127FFA7C00186A53 /* LGGOCXXClass.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LGGOCXXClass.cpp; sourceTree = ""; }; - BFE36852127FFA7C00186A53 /* LGGOCXXClass.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LGGOCXXClass.h; sourceTree = ""; }; + BFE36851127FFA7C00186A53 /* LGGOCXXClassRef.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; lineEnding = 0; path = LGGOCXXClassRef.cpp; sourceTree = ""; xcLanguageSpecificationIdentifier = xcode.lang.cpp; }; + BFE36852127FFA7C00186A53 /* LGGOCXXClassRef.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = LGGOCXXClassRef.h; sourceTree = ""; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; }; /* End PBXFileReference section */ /* Begin PBXFrameworksBuildPhase section */ @@ -260,16 +260,18 @@ isa = PBXGroup; children = ( BF3355511276523900F34934 /* Collections */, - BFE36852127FFA7C00186A53 /* LGGOCXXClass.h */, - BFE36851127FFA7C00186A53 /* LGGOCXXClass.cpp */, - BFA37A231280DC59002A0892 /* LGGOCXXObject.h */, - BFA37A221280DC59002A0892 /* LGGOCXXObject.cpp */, - BF232703127E8F5200496AF5 /* LGGOCXXNumber.h */, - BF232702127E8F5200496AF5 /* LGGOCXXNumber.cpp */, - BF532C14127954B90040B280 /* LGGOCXXType.h */, - BF532C13127954B90040B280 /* LGGOCXXType.cpp */, - BFD860D712781F2B00B7B5B3 /* LGGOCXXString.h */, - BFD860D612781F2B00B7B5B3 /* LGGOCXXString.cpp */, + BFE36852127FFA7C00186A53 /* LGGOCXXClassRef.h */, + BFE36851127FFA7C00186A53 /* LGGOCXXClassRef.cpp */, + BFA37A231280DC59002A0892 /* LGGOCXXObjectRef.h */, + BFA37A221280DC59002A0892 /* LGGOCXXObjectRef.cpp */, + BF232703127E8F5200496AF5 /* LGGOCXXNumberRef.h */, + BF232702127E8F5200496AF5 /* LGGOCXXNumberRef.cpp */, + BFD860D712781F2B00B7B5B3 /* LGGOCXXStringRef.h */, + BFD860D612781F2B00B7B5B3 /* LGGOCXXStringRef.cpp */, + BF532C14127954B90040B280 /* LGGOCXXReference.h */, + BF532C13127954B90040B280 /* LGGOCXXReference.cpp */, + BF8B7F59128DD72300B39D0A /* LGGOCXXReferenceMetadata.h */, + BF8B7F5A128DD72300B39D0A /* LGGOCXXReferenceMetadata.cpp */, ); path = Types; sourceTree = ""; @@ -278,8 +280,6 @@ isa = PBXGroup; children = ( BFD68E4C1278C4DC004CBBD2 /* unicode */, - BF3355761276523900F34934 /* LGGOCXXAddress.h */, - BF7C08A912832CC100BFD1DB /* LGGOCXXAddress.cpp */, BF3355771276523900F34934 /* LGGOByteOrder.h */, ); path = Utilities; @@ -307,8 +307,8 @@ BFCFF20F1280D53000C593F7 /* HackArray */ = { isa = PBXGroup; children = ( - BFA37A1A1280D5CC002A0892 /* LGGOCXXHackArray.h */, - BFA37A1B1280D5CC002A0892 /* LGGOCXXHackArray.cpp */, + BFA37A1A1280D5CC002A0892 /* LGGOCXXHackArrayRef.h */, + BFA37A1B1280D5CC002A0892 /* LGGOCXXHackArrayRef.cpp */, ); name = HackArray; path = Array/HackArray; @@ -337,24 +337,24 @@ BF33558D1276523900F34934 /* LGGOCXXStoreContext.h in Headers */, BF33558F1276523900F34934 /* LGGOCXXStoreHash.h in Headers */, BF3355911276523900F34934 /* LGGOCXXStoreSegment.h in Headers */, - BF33559A1276523900F34934 /* LGGOCXXAddress.h in Headers */, BF33559B1276523900F34934 /* LGGOByteOrder.h in Headers */, - BFD860D912781F2B00B7B5B3 /* LGGOCXXString.h in Headers */, + BFD860D912781F2B00B7B5B3 /* LGGOCXXStringRef.h in Headers */, BFD68E511278C519004CBBD2 /* checked.h in Headers */, BFD68E531278C52B004CBBD2 /* core.h in Headers */, BFD68E551278C538004CBBD2 /* unchecked.h in Headers */, - BF532C16127954B90040B280 /* LGGOCXXType.h in Headers */, + BF532C16127954B90040B280 /* LGGOCXXReference.h in Headers */, BF532C1E1279690C0040B280 /* LGGOGraphContext.h in Headers */, BF532C2212796F240040B280 /* LGGOGraph.h in Headers */, - BF232705127E8F5200496AF5 /* LGGOCXXNumber.h in Headers */, + BF232705127E8F5200496AF5 /* LGGOCXXNumberRef.h in Headers */, BFE3684D127F615200186A53 /* utf8.h in Headers */, - BFE36854127FFA7C00186A53 /* LGGOCXXClass.h in Headers */, + BFE36854127FFA7C00186A53 /* LGGOCXXClassRef.h in Headers */, BF0234341280D2F2004390C4 /* LGGONumber.h in Headers */, BF0234361280D2F2004390C4 /* LGGOString.h in Headers */, BF0234391280D312004390C4 /* LGGOClass.h in Headers */, - BFA37A1C1280D5CC002A0892 /* LGGOCXXHackArray.h in Headers */, + BFA37A1C1280D5CC002A0892 /* LGGOCXXHackArrayRef.h in Headers */, BFA37A201280D930002A0892 /* LGGOMutableArray.h in Headers */, - BFA37A251280DC59002A0892 /* LGGOCXXObject.h in Headers */, + BFA37A251280DC59002A0892 /* LGGOCXXObjectRef.h in Headers */, + BF8B7F5B128DD72300B39D0A /* LGGOCXXReferenceMetadata.h in Headers */, ); runOnlyForDeploymentPostprocessing = 0; }; @@ -447,19 +447,19 @@ BF33558C1276523900F34934 /* LGGOCXXStoreContext.cpp in Sources */, BF33558E1276523900F34934 /* LGGOCXXStoreHash.cpp in Sources */, BF3355901276523900F34934 /* LGGOCXXStoreSegment.cpp in Sources */, - BFD860D812781F2B00B7B5B3 /* LGGOCXXString.cpp in Sources */, - BF532C15127954B90040B280 /* LGGOCXXType.cpp in Sources */, + BFD860D812781F2B00B7B5B3 /* LGGOCXXStringRef.cpp in Sources */, + BF532C15127954B90040B280 /* LGGOCXXReference.cpp in Sources */, BF532C1F1279690C0040B280 /* LGGOGraphContext.mm in Sources */, BF532C2312796F240040B280 /* LGGOGraph.mm in Sources */, - BF232704127E8F5200496AF5 /* LGGOCXXNumber.cpp in Sources */, - BFE36853127FFA7C00186A53 /* LGGOCXXClass.cpp in Sources */, + BF232704127E8F5200496AF5 /* LGGOCXXNumberRef.cpp in Sources */, + BFE36853127FFA7C00186A53 /* LGGOCXXClassRef.cpp in Sources */, BF0234331280D2F2004390C4 /* LGGONumber.mm in Sources */, BF0234351280D2F2004390C4 /* LGGOString.mm in Sources */, BF02343A1280D312004390C4 /* LGGOClass.mm in Sources */, - BFA37A1D1280D5CC002A0892 /* LGGOCXXHackArray.cpp in Sources */, + BFA37A1D1280D5CC002A0892 /* LGGOCXXHackArrayRef.cpp in Sources */, BFA37A211280D930002A0892 /* LGGOMutableArray.mm in Sources */, - BFA37A241280DC59002A0892 /* LGGOCXXObject.cpp in Sources */, - BF7C08AA12832CC100BFD1DB /* LGGOCXXAddress.cpp in Sources */, + BFA37A241280DC59002A0892 /* LGGOCXXObjectRef.cpp in Sources */, + BF8B7F5C128DD72300B39D0A /* LGGOCXXReferenceMetadata.cpp in Sources */, ); runOnlyForDeploymentPostprocessing = 0; }; diff --git a/Source/Storage/LGGOCXXMemoryDescriptor.h b/Source/Storage/LGGOCXXMemoryDescriptor.h index 7297be3..4db7e8f 100644 --- a/Source/Storage/LGGOCXXMemoryDescriptor.h +++ b/Source/Storage/LGGOCXXMemoryDescriptor.h @@ -36,7 +36,7 @@ extern LGGOCXXSharedMemoryDescriptor NULL_DESCRIPTOR; #include -#include "LGGOCXXAddress.h" +#include "LGGOCXXReferenceMetadata.h" #include "LGGOCXXStoreHash.h" virtual class LGGOCXXCoreMemoryDescriptor : public std::tr1::enable_shared_from_this { diff --git a/Source/Storage/LGGOCXXStoreContext.cpp b/Source/Storage/LGGOCXXStoreContext.cpp index b591436..eca6eeb 100644 --- a/Source/Storage/LGGOCXXStoreContext.cpp +++ b/Source/Storage/LGGOCXXStoreContext.cpp @@ -26,7 +26,7 @@ #include -#include "LGGOCXXType.h" +#include "LGGOCXXReference.h" #include "LGGOCXXStore.h" #include "LGGOCXXStoreSegment.h" #include "LGGOCXXMemoryDescriptor.h" @@ -71,42 +71,42 @@ void LGGOCXXStoreContext::commit (void) { //FIXME we need to use a locking protocol here } -LGGOCXXType * LGGOCXXStoreContext::rootObject(void) { - LGGOCXXSharedAddress address(getAddress(1<<4)); +LGGOCXXReference * LGGOCXXStoreContext::rootObject(void) { + LGGOCXXSharedReference address(getAddress(1<<4)); return *address; } -void LGGOCXXStoreContext::setRootObject(LGGOCXXType *T) { - LGGOCXXSharedAddress address(shared_from_this(), 1<<4); +void LGGOCXXStoreContext::setRootObject(LGGOCXXReference *T) { + LGGOCXXSharedReference address(shared_from_this(), 1<<4); address.setType(T); } -LGGOCXXSharedAddress LGGOCXXStoreContext::getAddress (uint64_t address) { - std::map::iterator i = addresses.find(address); +LGGOCXXSharedReference LGGOCXXStoreContext::getAddress (uint64_t address) { + std::map::iterator i = addresses.find(address); if (i == addresses.end()) { - return LGGOCXXSharedAddress(i->second); + return LGGOCXXSharedReference(i->second); } else { assert(0); - LGGOCXXSharedAddress retval = LGGOCXXSharedAddress(shared_from_this(), address); - setAddressForAddressValue(LGGOCXXWeakAddress(retval), address); + LGGOCXXSharedReference retval = LGGOCXXSharedReference(shared_from_this(), address); + setAddressForAddressValue(LGGOCXXWeakReference(retval), address); return retval; } }; -void LGGOCXXStoreContext::setAddressForAddressValue(const LGGOCXXWeakAddress& address, uint64_t addressValue) { +void LGGOCXXStoreContext::setAddressForAddressValue(const LGGOCXXWeakReference& address, uint64_t addressValue) { // addresses[addressValue] = address; - addresses.insert(std::pair(addressValue, address)); + addresses.insert(std::pair(addressValue, address)); } -LGGOCXXSharedAddress LGGOCXXStoreContext::getAddressForAddressValue(uint64_t addressValue) { - std::map::iterator i = addresses.find(addressValue); +LGGOCXXSharedReference LGGOCXXStoreContext::getAddressForAddressValue(uint64_t addressValue) { + std::map::iterator i = addresses.find(addressValue); if (i != addresses.end()) { - return LGGOCXXSharedAddress(i->second); + return LGGOCXXSharedReference(i->second); } - return LGGOCXXSharedAddress(); + return LGGOCXXSharedReference(); } LGGOCXXSharedMemoryDescriptor LGGOCXXStoreContext::getDescriptorForAddress (uint64_t address) { diff --git a/Source/Storage/LGGOCXXStoreContext.h b/Source/Storage/LGGOCXXStoreContext.h index c63e414..c1ce73e 100644 --- a/Source/Storage/LGGOCXXStoreContext.h +++ b/Source/Storage/LGGOCXXStoreContext.h @@ -39,8 +39,8 @@ typedef std::tr1::weak_ptr LGGOCXXWeakStoreContext; #include "LGGOCXXMemoryDescriptor.h" #include "LGGOCXXStore.h" #include "LGGOCXXStoreSegment.h" -#include "LGGOCXXType.h" -#include "LGGOCXXAddress.h" +#include "LGGOCXXReference.h" +#include "LGGOCXXReferenceMetadata.h" class LGGOCXXWritableStoreSegment; @@ -51,7 +51,7 @@ class LGGOCXXStoreContext : public std::tr1::enable_shared_from_this segments; uint64_t nextAddressValue; - std::map addresses; + std::map addresses; //FIXME this should be weak, but without native types that can bump shared_ptrs it needs to be strong for now public: explicit LGGOCXXStoreContext(const LGGOCXXSharedStore &S); @@ -59,14 +59,14 @@ class LGGOCXXStoreContext : public std::tr1::enable_shared_from_this::iterator i = memoryObjects.find(address); + std::map::iterator i = memoryObjects.find(address); if (i != memoryObjects.end()) { retval = i->second; @@ -119,7 +119,7 @@ LGGOCXXSharedMemoryDescriptor LGGOCXXWritableStoreSegment::getDescriptorForAddre LGGOCXXSharedMemoryDescriptor LGGOCXXWritableStoreSegment::serializeToMemory(void) { std::map hashMap; std::vector > compressedDecriptors; - std::map::iterator i; + std::map::iterator i; std::map::iterator j; diff --git a/Source/Storage/LGGOCXXStoreSegment.h b/Source/Storage/LGGOCXXStoreSegment.h index f20b288..add959d 100644 --- a/Source/Storage/LGGOCXXStoreSegment.h +++ b/Source/Storage/LGGOCXXStoreSegment.h @@ -40,7 +40,7 @@ typedef std::tr1::shared_ptr LGGOCXXSharedStoreSegment; #include -#include "LGGOCXXAddress.h" +#include "LGGOCXXReferenceMetadata.h" #include "LGGOCXXMemoryDescriptor.h" //FIXME we should seperate pointer and hash lookups to support split storage @@ -54,7 +54,7 @@ virtual class LGGOCXXBaseStoreSegment : public std::tr1::enable_shared_from_this #if 0 class LGGOCXXWritableStoreSegment : public LGGOCXXBaseStoreSegment { private: - std::map memoryObjects; + std::map memoryObjects; protected: public: LGGOCXXSharedMemoryDescriptor serializeToMemory(void); diff --git a/Source/Types/Collections/HackArray/LGGOCXXHackArray.cpp b/Source/Types/Collections/HackArray/LGGOCXXHackArray.cpp deleted file mode 100644 index e3b544c..0000000 --- a/Source/Types/Collections/HackArray/LGGOCXXHackArray.cpp +++ /dev/null @@ -1,71 +0,0 @@ -/* Copyright (c) 2010 GLsoft.mobi - - Permission is hereby granted, free of charge, to any person obtaining a copy - of this software and associated documentation files (the "Software"), to deal - in the Software without restriction, including without limitation the rights - to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - copies of the Software, and to permit persons to whom the Software is - furnished to do so, subject to the following conditions: - - The above copyright notice and this permission notice shall be included in - all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - THE SOFTWARE. - - */ - -#include "LGGOCXXHackArray.h" - -uint64_t LGGOCXXHackArray::getCount(void) { - return objects.size(); -} - -LGGOCXXSharedAddress LGGOCXXHackArray::getObjectAtIndex(uint64_t i) { - assert(objects.size() > i); - return LGGOCXXSharedAddress(objects[i]); -} - -void LGGOCXXHackArray::addObject(const LGGOCXXSharedAddress& object) { - objects.push_back(LGGOCXXWeakAddress(object)); -} - -void LGGOCXXHackArray::insertObjectAtIndex(const LGGOCXXSharedAddress& object, uint64_t index) { - std::vector::iterator i = objects.begin()+index; - objects.insert(i, LGGOCXXWeakAddress(object)); -} - -void LGGOCXXHackArray::removeLastObject (void) { - objects.pop_back(); -} - -void LGGOCXXHackArray::removeObjectAtIndex(uint64_t index) { - std::vector::iterator i = objects.begin()+index; - objects.erase(i); -} - -void LGGOCXXHackArray::replaceObjectAtIndexWithObject(const LGGOCXXSharedAddress& object, uint64_t index) { - std::vector::iterator i = objects.begin()+index; - objects[index] = LGGOCXXWeakAddress(object); -} - -uint64_t LGGOCXXHackArray::getTagValue (void) { - return 0; -} - -LGGOCXXSharedMemoryDescriptor LGGOCXXHackArray::getSerializedData (void) { - assert(0); -} - -bool LGGOCXXHackArray::isDirty(void) { - return dirty; -} - -bool LGGOCXXHackArray::isDusty(void) { - return false; -} \ No newline at end of file diff --git a/Source/Types/Collections/HackArray/LGGOCXXHackArrayRef.cpp b/Source/Types/Collections/HackArray/LGGOCXXHackArrayRef.cpp new file mode 100644 index 0000000..aa1aaa2 --- /dev/null +++ b/Source/Types/Collections/HackArray/LGGOCXXHackArrayRef.cpp @@ -0,0 +1,67 @@ +/* Copyright (c) 2010 GLsoft.mobi + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. + + */ + +#include "LGGOCXXHackArrayRef.h" + +LGGOCXXSharedReference LGGOCXXHackArrayRef::create(const LGGOCXXSharedStoreContext& C) { + return LGGOCXXSharedReference(C, new LGGOCXXHackArrayRef()); +} + +uint64_t LGGOCXXHackArrayRef::getCount(void) { + return objects.size(); +} + +LGGOCXXSharedReference LGGOCXXHackArrayRef::getObjectAtIndex(uint64_t i) { + assert(objects.size() > i); + return LGGOCXXSharedReference(objects[i]); +} + +void LGGOCXXHackArrayRef::addObject(const LGGOCXXSharedReference& object) { + objects.push_back(LGGOCXXWeakReference(object)); +} + +void LGGOCXXHackArrayRef::insertObjectAtIndex(const LGGOCXXSharedReference& object, uint64_t index) { + std::vector::iterator i = objects.begin()+index; + objects.insert(i, LGGOCXXWeakReference(object)); +} + +void LGGOCXXHackArrayRef::removeLastObject (void) { + objects.pop_back(); +} + +void LGGOCXXHackArrayRef::removeObjectAtIndex(uint64_t index) { + std::vector::iterator i = objects.begin()+index; + objects.erase(i); +} + +void LGGOCXXHackArrayRef::replaceObjectAtIndexWithObject(const LGGOCXXSharedReference& object, uint64_t index) { + std::vector::iterator i = objects.begin()+index; + objects[index] = LGGOCXXWeakReference(object); +} + +uint64_t LGGOCXXHackArrayRef::getTagValue (void) { + return 0; +} + +LGGOCXXSharedMemoryDescriptor LGGOCXXHackArrayRef::getSerializedData (void) { + assert(0); +} \ No newline at end of file diff --git a/Source/Types/Collections/HackArray/LGGOCXXHackArray.h b/Source/Types/Collections/HackArray/LGGOCXXHackArrayRef.h similarity index 72% rename from Source/Types/Collections/HackArray/LGGOCXXHackArray.h rename to Source/Types/Collections/HackArray/LGGOCXXHackArrayRef.h index 2969764..a4d6050 100644 --- a/Source/Types/Collections/HackArray/LGGOCXXHackArray.h +++ b/Source/Types/Collections/HackArray/LGGOCXXHackArrayRef.h @@ -22,9 +22,9 @@ #include -#include "LGGOCXXType.h" +#include "LGGOCXXReference.h" -class LGGOCXXObject; +class LGGOCXXObjectRef; //FIXME this should really be an STL compatible interface @@ -32,24 +32,23 @@ class LGGOCXXObject; // 1) It is not implemented // 2) This whole class will go away -class LGGOCXXHackArray : public LGGOCXXType { +class LGGOCXXHackArrayRef : public LGGOCXXReference { private: - std::vector objects; - bool dirty:1; + std::vector objects; + LGGOCXXHackArrayRef(void) : LGGOCXXReference() { } + public: - LGGOCXXHackArray(void) : LGGOCXXType(), dirty(true) { } + static LGGOCXXSharedReference create (const LGGOCXXSharedStoreContext& C); uint64_t getCount(void); - LGGOCXXSharedAddress getObjectAtIndex(uint64_t i); + LGGOCXXSharedReference getObjectAtIndex(uint64_t i); - void addObject(const LGGOCXXSharedAddress& object); - void insertObjectAtIndex(const LGGOCXXSharedAddress& object, uint64_t index); + void addObject(const LGGOCXXSharedReference& object); + void insertObjectAtIndex(const LGGOCXXSharedReference& object, uint64_t index); void removeLastObject (void); void removeObjectAtIndex(uint64_t index); - void replaceObjectAtIndexWithObject(const LGGOCXXSharedAddress& object, uint64_t index); + void replaceObjectAtIndexWithObject(const LGGOCXXSharedReference& object, uint64_t index); virtual uint64_t getTagValue (void); virtual LGGOCXXSharedMemoryDescriptor getSerializedData (void); - virtual bool isDirty(void); - virtual bool isDusty(void); }; \ No newline at end of file diff --git a/Source/Types/LGGOCXXClass.cpp b/Source/Types/LGGOCXXClassRef.cpp similarity index 74% rename from Source/Types/LGGOCXXClass.cpp rename to Source/Types/LGGOCXXClassRef.cpp index 961d2d6..e967850 100644 --- a/Source/Types/LGGOCXXClass.cpp +++ b/Source/Types/LGGOCXXClassRef.cpp @@ -21,23 +21,27 @@ */ -#include "LGGOCXXClass.h" +#include "LGGOCXXClassRef.h" -LGGOCXXClass::LGGOCXXClass(std::string N) : LGGOCXXType(), name(N) { +LGGOCXXSharedReference LGGOCXXClassRef::create(const LGGOCXXSharedStoreContext& C, std::string S) { + return LGGOCXXSharedReference (C, new LGGOCXXClassRef(S)); +} + +LGGOCXXClassRef::LGGOCXXClassRef(std::string N) : LGGOCXXReference(), name(N) { } -void LGGOCXXClass::addProperty(std::string name, LGGOCXXScalarEncodingType type) { +void LGGOCXXClassRef::addProperty(std::string name, LGGOCXXScalarEncodingType type) { assert(relations.count(name) == 0); //While we can structurally support scheme style duality, ObjC can't properties[name] = type; } -void LGGOCXXClass::addRelation(std::string name, LGGOCXXRelationEncodingType type, LGGOCXXRelationSemanticsType semantics) { +void LGGOCXXClassRef::addRelation(std::string name, LGGOCXXRelationEncodingType type, LGGOCXXRelationSemanticsType semantics) { assert(properties.count(name) == 0); //While we can structurally support scheme style duality, ObjC can't relations[name] = LGGOCXXRelationTuple(type, semantics); } -LGGOCXXScalarEncodingType LGGOCXXClass::getPropertyType(std::string name) { +LGGOCXXScalarEncodingType LGGOCXXClassRef::getPropertyType(std::string name) { assert(properties.count(name) == 1); return properties[name]; } @@ -63,14 +67,14 @@ uint8_t typeSize (LGGOCXXScalarEncodingType type) { } } -uint32_t LGGOCXXClass::getPropertyOffset(std::string name) { +uint32_t LGGOCXXClassRef::getPropertyOffset(std::string name) { assert(properties.count(name) == 1); LGGOCXXScalarEncodingType type = properties[name]; uint8_t tSize = ::typeSize(type); //Properties come after relations - uint32_t retval = LGGOCXXADDRESS_SERIALIZED_SIZE*relations.size(); + uint32_t retval = LGGOCXXReferenceMetadata_SERIALIZED_SIZE*relations.size(); std::map::iterator i; @@ -90,17 +94,17 @@ uint32_t LGGOCXXClass::getPropertyOffset(std::string name) { return retval; } -LGGOCXXRelationEncodingType LGGOCXXClass::getRelationType(std::string name) { +LGGOCXXRelationEncodingType LGGOCXXClassRef::getRelationType(std::string name) { assert(relations.count(name) == 1); return std::tr1::get<0>(relations[name]); } -LGGOCXXRelationSemanticsType LGGOCXXClass::getRelationSemantics(std::string name) { +LGGOCXXRelationSemanticsType LGGOCXXClassRef::getRelationSemantics(std::string name) { assert(relations.count(name) == 1); return std::tr1::get<1>(relations[name]); } -uint32_t LGGOCXXClass::getRelationOffset(std::string name) { +uint32_t LGGOCXXClassRef::getRelationOffset(std::string name) { assert(relations.count(name) == 1); uint32_t retval = 0; @@ -118,10 +122,10 @@ uint32_t LGGOCXXClass::getRelationOffset(std::string name) { return retval; } -uint64_t LGGOCXXClass::getTagValue (void) { +uint64_t LGGOCXXClassRef::getTagValue (void) { return 0; } -LGGOCXXSharedMemoryDescriptor LGGOCXXClass::getSerializedData (void) { +LGGOCXXSharedMemoryDescriptor LGGOCXXClassRef::getSerializedData (void) { return NULL_DESCRIPTOR; } \ No newline at end of file diff --git a/Source/Types/LGGOCXXClass.h b/Source/Types/LGGOCXXClassRef.h similarity index 88% rename from Source/Types/LGGOCXXClass.h rename to Source/Types/LGGOCXXClassRef.h index bcc27c3..5a3d083 100644 --- a/Source/Types/LGGOCXXClass.h +++ b/Source/Types/LGGOCXXClassRef.h @@ -21,27 +21,30 @@ */ -#ifndef LGGOCXXCLASS_H -#define LGGOCXXCLASS_H +#ifndef LGGOCXXCLASSREF_H +#define LGGOCXXCLASSREF_H #include #include -#include "LGGOCXXType.h" +#include "LGGOCXXReference.h" //FIXME we should probably cache property and relationship offsets //Encoding and semantics typedef std::tr1::tuple LGGOCXXRelationTuple; -class LGGOCXXClass : public LGGOCXXType { +class LGGOCXXClassRef : public LGGOCXXReference { private: std::string name; std::map properties; std::map relations; bool dirty:1; -public: - explicit LGGOCXXClass(std::string N); + + explicit LGGOCXXClassRef(std::string N); +public: + static LGGOCXXSharedReference create(const LGGOCXXSharedStoreContext& C, std::string S); + void addProperty(std::string name, LGGOCXXScalarEncodingType type); void addRelation(std::string name, LGGOCXXRelationEncodingType type, LGGOCXXRelationSemanticsType semantics); diff --git a/Source/Types/LGGOCXXNumber.cpp b/Source/Types/LGGOCXXNumberRef.cpp similarity index 82% rename from Source/Types/LGGOCXXNumber.cpp rename to Source/Types/LGGOCXXNumberRef.cpp index 1ca6253..f96cf23 100644 --- a/Source/Types/LGGOCXXNumber.cpp +++ b/Source/Types/LGGOCXXNumberRef.cpp @@ -20,14 +20,18 @@ */ -#include "LGGOCXXNumber.h" +#include "LGGOCXXNumberRef.h" #define LGGO_NUMBER_DATAMASK ((uint64_t)0x07ffffffffffffff) #define LGGO_MAX_INT59 ((int64_t)0x03ffffffffffffff) #define LGGO_MIN_INT59 ((int64_t)(-1*LGGO_MAX_INT59)) -LGGOCXXNumber::LGGOCXXNumber(int64_t N) : LGGOCXXType(), rawValue(N) { +LGGOCXXSharedReference LGGOCXXNumberRef::create(const LGGOCXXSharedStoreContext& C, int64_t N) { + return LGGOCXXSharedReference (C, new LGGOCXXNumberRef(N)); +} + +LGGOCXXNumberRef::LGGOCXXNumberRef(int64_t N) : LGGOCXXReference(), rawValue(N) { rawValue = *((uint64_t *)&N); if (N >= 0) { @@ -62,11 +66,11 @@ LGGOCXXNumber::LGGOCXXNumber(int64_t N) : LGGOCXXType(), rawValue(N) { } } -LGGOCXXScalarEncodingType LGGOCXXNumber::getType(void) { +LGGOCXXScalarEncodingType LGGOCXXNumberRef::getType(void) { return type; } -uint64_t LGGOCXXNumber::getTagValue (void) { +uint64_t LGGOCXXNumberRef::getTagValue (void) { switch(type) { case kLGGOCXX64BitUnsignedNumberType: case kLGGOCXX32BitUnsignedNumberType: @@ -84,24 +88,24 @@ uint64_t LGGOCXXNumber::getTagValue (void) { } } -LGGOCXXSharedMemoryDescriptor LGGOCXXNumber::getSerializedData(void) { +LGGOCXXSharedMemoryDescriptor LGGOCXXNumberRef::getSerializedData(void) { return NULL_DESCRIPTOR; } -int64_t LGGOCXXNumber::signedValue (void) { +int64_t LGGOCXXNumberRef::signedValue (void) { return *((int64_t *)&rawValue); } -uint64_t LGGOCXXNumber::unsignedValue (void) { +uint64_t LGGOCXXNumberRef::unsignedValue (void) { return *((uint64_t *)&rawValue); } -float LGGOCXXNumber::floatValue(void) { +float LGGOCXXNumberRef::floatValue(void) { assert(0); return 0.0; } -double LGGOCXXNumber::doubleValue(void) { +double LGGOCXXNumberRef::doubleValue(void) { assert(0); return 0.0; } \ No newline at end of file diff --git a/Source/Types/LGGOCXXNumber.h b/Source/Types/LGGOCXXNumberRef.h similarity index 86% rename from Source/Types/LGGOCXXNumber.h rename to Source/Types/LGGOCXXNumberRef.h index e06578b..8c92ceb 100644 --- a/Source/Types/LGGOCXXNumber.h +++ b/Source/Types/LGGOCXXNumberRef.h @@ -21,10 +21,10 @@ */ -#ifndef LGGOCXXNUMBER_H -#define LGGOCXXNUMBER_H +#ifndef LGGOCXXNUMBERREF_H +#define LGGOCXXNUMBERREF_H -#include "LGGOCXXType.h" +#include "LGGOCXXReference.h" // Encoding // bits 0-3 number tag @@ -38,16 +38,19 @@ typedef enum { LGGOCXXIntegerTypeEncoding = 0, LGGOCXXUnsignedFloatTypEncodinge = 1 -} LGGOCXXNumberEncodingType; +} LGGOCXXNumberRefEncodingType; -class LGGOCXXNumber : public LGGOCXXType { +class LGGOCXXNumberRef : public LGGOCXXReference { private: uint64_t rawValue; LGGOCXXSharedMemoryDescriptor descriptor; LGGOCXXScalarEncodingType type; bool dirty:1; + + explicit LGGOCXXNumberRef(int64_t N); public: - explicit LGGOCXXNumber(int64_t N); + static LGGOCXXSharedReference create(const LGGOCXXSharedStoreContext& C, int64_t N); + LGGOCXXScalarEncodingType getType(void); int64_t signedValue (void); diff --git a/Source/Types/LGGOCXXObject.cpp b/Source/Types/LGGOCXXObjectRef.cpp similarity index 97% rename from Source/Types/LGGOCXXObject.cpp rename to Source/Types/LGGOCXXObjectRef.cpp index f419e8d..b98fe78 100644 --- a/Source/Types/LGGOCXXObject.cpp +++ b/Source/Types/LGGOCXXObjectRef.cpp @@ -19,4 +19,4 @@ THE SOFTWARE. */ -#include "LGGOCXXObject.h" +#include "LGGOCXXObjectRef.h" diff --git a/Source/Types/LGGOCXXObject.h b/Source/Types/LGGOCXXObjectRef.h similarity index 89% rename from Source/Types/LGGOCXXObject.h rename to Source/Types/LGGOCXXObjectRef.h index 49d41eb..c0121b2 100644 --- a/Source/Types/LGGOCXXObject.h +++ b/Source/Types/LGGOCXXObjectRef.h @@ -20,13 +20,13 @@ */ -#ifdef LGGOCXXOBJECT_H -#define LGGOCXXOBJECT_H +#ifndef LGGOCXXOBJECTREF_H +#define LGGOCXXOBJECTREF_H -#include "LGGOCXXType.h" +#include "LGGOCXXReference.h" -class LGGOCXXObject : LGGOCXXType { +class LGGOCXXObjectRef : LGGOCXXReference { -} +}; #endif \ No newline at end of file diff --git a/Source/Types/LGGOCXXType.cpp b/Source/Types/LGGOCXXReference.cpp similarity index 75% rename from Source/Types/LGGOCXXType.cpp rename to Source/Types/LGGOCXXReference.cpp index 4c77217..b7241d1 100644 --- a/Source/Types/LGGOCXXType.cpp +++ b/Source/Types/LGGOCXXReference.cpp @@ -20,28 +20,28 @@ */ -#include "LGGOCXXType.h" +#include "LGGOCXXReference.h" -LGGOCXXType::LGGOCXXType(void) : clientData(NULL) { +LGGOCXXReference::LGGOCXXReference(void) : clientData(NULL) { } -LGGOCXXWeakAddress LGGOCXXType::getAddress(void) { +LGGOCXXWeakReference LGGOCXXReference::getAddress(void) { return address; } -void LGGOCXXType::setAddress (const LGGOCXXWeakAddress &A) { +void LGGOCXXReference::setAddress (const LGGOCXXWeakReference &A) { address = A; } -void *LGGOCXXType::getNativeObject(void) { +void *LGGOCXXReference::getNativeObject(void) { return clientData; } -const LGGOCXXSharedStoreContext &LGGOCXXType::getContext(void) { +const LGGOCXXSharedStoreContext &LGGOCXXReference::getContext(void) { return address.getContext(); } -void LGGOCXXType::setNativeObject(void *D) { +void LGGOCXXReference::setNativeObject(void *D) { clientData = D; } \ No newline at end of file diff --git a/Source/Types/LGGOCXXType.h b/Source/Types/LGGOCXXReference.h similarity index 79% rename from Source/Types/LGGOCXXType.h rename to Source/Types/LGGOCXXReference.h index afcd656..c6e021c 100644 --- a/Source/Types/LGGOCXXType.h +++ b/Source/Types/LGGOCXXReference.h @@ -22,19 +22,17 @@ #include -virtual class LGGOCXXType; -//typedef std::tr1::shared_ptr LGGOCXXSharedType; -//typedef std::tr1::weak_ptr LGGOCXXWeakType; +virtual class LGGOCXXReference; -#ifndef LGGOCXXTYPE_H -#define LGGOCXXTYPE_H +#ifndef LGGOCXXREFERENCE_H +#define LGGOCXXREFERENCE_H #include #include "LGGOCXXStoreContext.h" #include "LGGOCXXMemoryDescriptor.h" -#include "LGGOCXXAddress.h" +#include "LGGOCXXReferenceMetadata.h" //FIXME should we support _Bool/c++ bool encoding? @@ -55,26 +53,26 @@ typedef enum { } LGGOCXXScalarEncodingType; typedef enum { - kLGGOCXXClassReferenceType = 0, - kLGGOCXXClassArrayType = 1, - kLGGOCXXClassSetType = 2, - kLGGOCXXClassDictionaryType = 3 + kLGGOCXXClassRefReferenceType = 0, + kLGGOCXXClassRefArrayType = 1, + kLGGOCXXClassRefSetType = 2, + kLGGOCXXClassRefDictionaryType = 3 } LGGOCXXRelationEncodingType; typedef enum { - kLGGOCXXClassByValueType = 0, - kLGGOCXXClassByReferenceType = 1 + kLGGOCXXClassRefByValueType = 0, + kLGGOCXXClassRefByReferenceType = 1 } LGGOCXXRelationSemanticsType; -class LGGOCXXType { +class LGGOCXXReference { private: - LGGOCXXWeakAddress address; + LGGOCXXWeakReference address; void *clientData; public: - explicit LGGOCXXType(void); + explicit LGGOCXXReference(void); - LGGOCXXWeakAddress getAddress(void); - void setAddress (const LGGOCXXWeakAddress &A); + LGGOCXXWeakReference getAddress(void); + void setAddress (const LGGOCXXWeakReference &A); const LGGOCXXSharedStoreContext& getContext(void); diff --git a/Source/Utilities/LGGOCXXAddress.cpp b/Source/Types/LGGOCXXReferenceMetadata.cpp similarity index 60% rename from Source/Utilities/LGGOCXXAddress.cpp rename to Source/Types/LGGOCXXReferenceMetadata.cpp index cef8015..757be5c 100644 --- a/Source/Utilities/LGGOCXXAddress.cpp +++ b/Source/Types/LGGOCXXReferenceMetadata.cpp @@ -24,7 +24,7 @@ #include -#include "LGGOCXXAddress.h" +#include "LGGOCXXReferenceMetadata.h" #include #include @@ -54,56 +54,56 @@ #pragma mark - #pragma mark Control Block Implementation -LGGOCXXAddress::LGGOCXXAddress(const LGGOCXXSharedStoreContext& C, LGGOCXXType *T) +LGGOCXXReferenceMetadata::LGGOCXXReferenceMetadata(const LGGOCXXSharedStoreContext& C, LGGOCXXReference *T) : context(C), strongRefCount(0), weakRefCount(0), dirty(false), dusty(false), type(T) { //Weak declare this weakAddr at top of scope to guarantee the addr is not deleted during setup - LGGOCXXWeakAddress weakAddr(this); + LGGOCXXWeakReference weakAddr(this); T->setAddress(weakAddr); address = context->getNextFreeAddress(); - context->setAddressForAddressValue(LGGOCXXWeakAddress(this), address); + context->setAddressForAddressValue(LGGOCXXWeakReference(this), address); LG_LOG("Create 0x%llx real address\n", getAddressValue()); assert(type->getAddress().getAddressValue() == address); } -LGGOCXXAddress::LGGOCXXAddress(const LGGOCXXSharedStoreContext& C, LGGOCXXType *T, uint64_t A) +LGGOCXXReferenceMetadata::LGGOCXXReferenceMetadata(const LGGOCXXSharedStoreContext& C, LGGOCXXReference *T, uint64_t A) : context(C), strongRefCount(0), weakRefCount(0), dirty(false), dusty(false), type(T), address(A) { //Weak declare this weakAddr at top of scope to guarantee the addr is not deleted during setup - LGGOCXXWeakAddress weakAddr(this); + LGGOCXXWeakReference weakAddr(this); T->setAddress(weakAddr); - context->setAddressForAddressValue(LGGOCXXWeakAddress(this), address); + context->setAddressForAddressValue(LGGOCXXWeakReference(this), address); LG_LOG("Create 0x%llx real address\n", getAddressValue()); assert(type->getAddress().getAddressValue() == address); assert(type->getAddress().getAddressValue() == A); } -const uint64_t LGGOCXXAddress::getAddressValue (void) { +const uint64_t LGGOCXXReferenceMetadata::getAddressValue (void) { return address; } -const LGGOSimpleType LGGOCXXAddress::getType (void) const { +const LGGOSimpleType LGGOCXXReferenceMetadata::getType (void) const { return static_cast(address | (uint64_t)0x00ff); } -const bool LGGOCXXAddress::isNative (void) const { +const bool LGGOCXXReferenceMetadata::isNative (void) const { return ((address | (uint64_t)0x00ff) == kLGGOAddressNativeType); } -const bool LGGOCXXAddress::isValid (void) const { +const bool LGGOCXXReferenceMetadata::isValid (void) const { return address != 0; } -uint64_t LGGOCXXAddress::getConcreteAddressValue (void) const { +uint64_t LGGOCXXReferenceMetadata::getConcreteAddressValue (void) const { return address; } -void LGGOCXXAddress::incrementStrongCount (void) { +void LGGOCXXReferenceMetadata::incrementStrongCount (void) { LG_LOG("Counts:%u/%u 0x%lx\n", strongRefCount, weakRefCount, (uintptr_t)this); LG_BACKTRACE(); strongRefCount++; } -void LGGOCXXAddress::decrementStrongCount (void) { +void LGGOCXXReferenceMetadata::decrementStrongCount (void) { LG_LOG("Counts:%u/%u 0x%lx\n", strongRefCount, weakRefCount, (uintptr_t)this); LG_BACKTRACE(); assert(strongRefCount > 0); @@ -114,13 +114,13 @@ void LGGOCXXAddress::decrementStrongCount (void) { } } -void LGGOCXXAddress::incrementWeakCount (void) { +void LGGOCXXReferenceMetadata::incrementWeakCount (void) { LG_LOG("Counts:%u/%u 0x%lx\n", strongRefCount, weakRefCount, (uintptr_t)this); LG_BACKTRACE(); weakRefCount++; } -void LGGOCXXAddress::decrementWeakCount (void) { +void LGGOCXXReferenceMetadata::decrementWeakCount (void) { LG_LOG("Counts:%u/%u 0x%lx\n", strongRefCount, weakRefCount, (uintptr_t)this); LG_BACKTRACE(); assert(weakRefCount > 0); @@ -132,84 +132,84 @@ void LGGOCXXAddress::decrementWeakCount (void) { } -bool LGGOCXXAddress::operator== (const LGGOCXXAddress& A) { +bool LGGOCXXReferenceMetadata::operator== (const LGGOCXXReferenceMetadata& A) { return (address == A.address); } -bool LGGOCXXAddress::operator> (const LGGOCXXAddress& b) const { +bool LGGOCXXReferenceMetadata::operator> (const LGGOCXXReferenceMetadata& b) const { return address > b.address; } -bool LGGOCXXAddress::operator< (const LGGOCXXAddress& b) const { +bool LGGOCXXReferenceMetadata::operator< (const LGGOCXXReferenceMetadata& b) const { return address < b.address; } -const LGGOCXXSharedStoreContext& LGGOCXXAddress::getContext(void) { +const LGGOCXXSharedStoreContext& LGGOCXXReferenceMetadata::getContext(void) { return context; } -LGGOCXXType * LGGOCXXAddress::getType (void) { +LGGOCXXReference * LGGOCXXReferenceMetadata::getType (void) { return type; } -void LGGOCXXAddress::setType (LGGOCXXType *T) { +void LGGOCXXReferenceMetadata::setType (LGGOCXXReference *T) { type = T; } -bool LGGOCXXAddress::getDirty (void) { +bool LGGOCXXReferenceMetadata::getDirty (void) { return dirty; } -void LGGOCXXAddress::setDirty (bool D) { +void LGGOCXXReferenceMetadata::setDirty (bool D) { dirty = D; } -bool LGGOCXXAddress::getDusty (void) { +bool LGGOCXXReferenceMetadata::getDusty (void) { return dusty; } -void LGGOCXXAddress::setDusty (bool D) { +void LGGOCXXReferenceMetadata::setDusty (bool D) { dusty = D; } -bool LGGOCXXSharedAddress::getDirty (void) { +bool LGGOCXXSharedReference::getDirty (void) { return address->getDirty(); } -void LGGOCXXSharedAddress::setDirty (bool D) { +void LGGOCXXSharedReference::setDirty (bool D) { address->setDirty(D); } -bool LGGOCXXSharedAddress::getDusty (void) { +bool LGGOCXXSharedReference::getDusty (void) { return address->getDusty(); } -void LGGOCXXSharedAddress::setDusty (bool D) { +void LGGOCXXSharedReference::setDusty (bool D) { address->setDusty(D); } #pragma mark - #pragma mark Strong Pointer Implementation -LGGOCXXSharedAddress::LGGOCXXSharedAddress(void) : address(NULL) { +LGGOCXXSharedReference::LGGOCXXSharedReference(void) : address(NULL) { //printf("Create NULL strong address\n"); } -LGGOCXXSharedAddress::LGGOCXXSharedAddress(const LGGOCXXWeakAddress& A) : address(A.address) { +LGGOCXXSharedReference::LGGOCXXSharedReference(const LGGOCXXWeakReference& A) : address(A.address) { if (address) { address->incrementStrongCount(); } } -LGGOCXXSharedAddress::LGGOCXXSharedAddress(const LGGOCXXSharedAddress& A) : address(A.address) { +LGGOCXXSharedReference::LGGOCXXSharedReference(const LGGOCXXSharedReference& A) : address(A.address) { if (address) { address->incrementStrongCount(); } } -LGGOCXXSharedAddress::LGGOCXXSharedAddress(const LGGOCXXSharedStoreContext& C, uint64_t A) { +LGGOCXXSharedReference::LGGOCXXSharedReference(const LGGOCXXSharedStoreContext& C, uint64_t A) { assert(A != 0); - LGGOCXXSharedAddress existingAddress = C->getAddressForAddressValue(A); + LGGOCXXSharedReference existingAddress = C->getAddressForAddressValue(A); if (existingAddress.isValid()) { address = existingAddress.address; address->incrementStrongCount(); @@ -220,66 +220,66 @@ LGGOCXXSharedAddress::LGGOCXXSharedAddress(const LGGOCXXSharedStoreContext& C, u //printf("Create 0x%llx strong address\n", address->getAddressValue()); } -LGGOCXXSharedAddress::LGGOCXXSharedAddress(const LGGOCXXSharedStoreContext& C, LGGOCXXType *T) { +LGGOCXXSharedReference::LGGOCXXSharedReference(const LGGOCXXSharedStoreContext& C, LGGOCXXReference *T) { uint64_t tagValue = T->getTagValue(); if (tagValue) { - LGGOCXXSharedAddress existingAddress = C->getAddressForAddressValue(tagValue); + LGGOCXXSharedReference existingAddress = C->getAddressForAddressValue(tagValue); if (existingAddress.isValid()) { address = existingAddress.address; } else { - address = new LGGOCXXAddress(C, T, tagValue); + address = new LGGOCXXReferenceMetadata(C, T, tagValue); } assert(address->getAddressValue() == tagValue); //printf("Create 0x%llx strong address\n", address->getAddressValue()); } else { - address = new LGGOCXXAddress(C, T); + address = new LGGOCXXReferenceMetadata(C, T); } address->incrementStrongCount(); //printf("Create 0x%llx strong address\n", address->getAddressValue()); } -LGGOCXXSharedAddress::~LGGOCXXSharedAddress(void) { +LGGOCXXSharedReference::~LGGOCXXSharedReference(void) { if (address) { address->decrementStrongCount(); } } -const LGGOCXXSharedStoreContext& LGGOCXXSharedAddress::getContext(void) { +const LGGOCXXSharedStoreContext& LGGOCXXSharedReference::getContext(void) { assert(address != NULL); return address->getContext(); } -uint64_t LGGOCXXSharedAddress::getAddressValue(void) { +uint64_t LGGOCXXSharedReference::getAddressValue(void) { return address->getAddressValue(); } -LGGOCXXType *LGGOCXXSharedAddress::getType (void) { +LGGOCXXReference *LGGOCXXSharedReference::getType (void) { assert(address != NULL); return address->getType(); } -void LGGOCXXSharedAddress::setType (LGGOCXXType *T) { +void LGGOCXXSharedReference::setType (LGGOCXXReference *T) { assert(address != NULL); address->setType(T); } -bool LGGOCXXSharedAddress::isValid (void) { +bool LGGOCXXSharedReference::isValid (void) { return (address != NULL); } -LGGOCXXType *LGGOCXXSharedAddress::operator* (void) const { +LGGOCXXReference *LGGOCXXSharedReference::operator* (void) const { assert(address != NULL); return address->getType(); } -LGGOCXXType *LGGOCXXSharedAddress::operator-> (void) const { +LGGOCXXReference *LGGOCXXSharedReference::operator-> (void) const { assert(address != NULL); return address->getType(); } -LGGOCXXSharedAddress& LGGOCXXSharedAddress::operator= (const LGGOCXXSharedAddress& A) { +LGGOCXXSharedReference& LGGOCXXSharedReference::operator= (const LGGOCXXSharedReference& A) { if (address) { address->decrementStrongCount(); } @@ -293,11 +293,11 @@ LGGOCXXSharedAddress& LGGOCXXSharedAddress::operator= (const LGGOCXXSharedAddres #pragma mark - #pragma mark Weak Pointer Implementation -LGGOCXXWeakAddress::LGGOCXXWeakAddress(void) : address(NULL) { +LGGOCXXWeakReference::LGGOCXXWeakReference(void) : address(NULL) { // printf("Create NULL weak address\n"); } -LGGOCXXWeakAddress::LGGOCXXWeakAddress(LGGOCXXAddress *A) : address(A) { +LGGOCXXWeakReference::LGGOCXXWeakReference(LGGOCXXReferenceMetadata *A) : address(A) { // printf("Create 0x%llx weak address\n", A->getAddressValue()); if (address) { address->incrementWeakCount(); @@ -305,38 +305,38 @@ LGGOCXXWeakAddress::LGGOCXXWeakAddress(LGGOCXXAddress *A) : address(A) { } -LGGOCXXWeakAddress::LGGOCXXWeakAddress(const LGGOCXXWeakAddress& A) : address(A.address) { +LGGOCXXWeakReference::LGGOCXXWeakReference(const LGGOCXXWeakReference& A) : address(A.address) { if (address) { address->incrementWeakCount(); } } -LGGOCXXWeakAddress::LGGOCXXWeakAddress(const LGGOCXXSharedAddress& A) : address(A.address) { +LGGOCXXWeakReference::LGGOCXXWeakReference(const LGGOCXXSharedReference& A) : address(A.address) { if (address) { address->incrementWeakCount(); } } -LGGOCXXWeakAddress::~LGGOCXXWeakAddress(void) { +LGGOCXXWeakReference::~LGGOCXXWeakReference(void) { if (address) { address->decrementWeakCount(); } } -const LGGOCXXSharedStoreContext& LGGOCXXWeakAddress::getContext(void) { +const LGGOCXXSharedStoreContext& LGGOCXXWeakReference::getContext(void) { assert(address != NULL); return address->getContext(); } -uint64_t LGGOCXXWeakAddress::getAddressValue(void) { +uint64_t LGGOCXXWeakReference::getAddressValue(void) { return address->getAddressValue(); } -bool LGGOCXXWeakAddress::isValid (void) { +bool LGGOCXXWeakReference::isValid (void) { return (address != NULL); } -LGGOCXXWeakAddress& LGGOCXXWeakAddress::operator= (const LGGOCXXWeakAddress& A) { +LGGOCXXWeakReference& LGGOCXXWeakReference::operator= (const LGGOCXXWeakReference& A) { if (address) { address->decrementWeakCount(); } @@ -347,18 +347,18 @@ LGGOCXXWeakAddress& LGGOCXXWeakAddress::operator= (const LGGOCXXWeakAddress& A) return *this; } -bool LGGOCXXWeakAddress::getDirty (void) { +bool LGGOCXXWeakReference::getDirty (void) { return address->getDirty(); } -void LGGOCXXWeakAddress::setDirty (bool D) { +void LGGOCXXWeakReference::setDirty (bool D) { address->setDirty(D); } -bool LGGOCXXWeakAddress::getDusty (void) { +bool LGGOCXXWeakReference::getDusty (void) { return address->getDusty(); } -void LGGOCXXWeakAddress::setDusty (bool D) { +void LGGOCXXWeakReference::setDusty (bool D) { address->setDusty(D); } diff --git a/Source/Utilities/LGGOCXXAddress.h b/Source/Types/LGGOCXXReferenceMetadata.h similarity index 58% rename from Source/Utilities/LGGOCXXAddress.h rename to Source/Types/LGGOCXXReferenceMetadata.h index e6f1cce..c0a742b 100644 --- a/Source/Utilities/LGGOCXXAddress.h +++ b/Source/Types/LGGOCXXReferenceMetadata.h @@ -20,16 +20,16 @@ */ -class LGGOCXXSharedAddress; -class LGGOCXXWeakAddress; +class LGGOCXXSharedReference; +class LGGOCXXWeakReference; -#include "LGGOCXXType.h" +#include "LGGOCXXReference.h" #include "LGGOCXXStoreContext.h" -#ifndef LGGOADDRESS_H -#define LGGOADDRESS_H +#ifndef LGGOREFERENCEMETADATA_H +#define LGGOREFERENCEMETADATA_H -#define LGGOCXXADDRESS_SERIALIZED_SIZE (8) +#define LGGOCXXReferenceMetadata_SERIALIZED_SIZE (8) typedef enum { kLGGOAddressNativeType = 0, @@ -45,18 +45,18 @@ typedef enum { //FIXME we can be stupid clever here and half the size by using a union, but it is tricky -class LGGOCXXAddress { +class LGGOCXXReferenceMetadata { private: uint64_t address; LGGOCXXSharedStoreContext context; - LGGOCXXType *type; + LGGOCXXReference *type; uint32_t strongRefCount; uint32_t weakRefCount; bool dirty:1; bool dusty:1; public: - explicit LGGOCXXAddress(const LGGOCXXSharedStoreContext& C, LGGOCXXType *T, uint64_t A); - explicit LGGOCXXAddress(const LGGOCXXSharedStoreContext& C, LGGOCXXType *T); + explicit LGGOCXXReferenceMetadata(const LGGOCXXSharedStoreContext& C, LGGOCXXReference *T, uint64_t A); + explicit LGGOCXXReferenceMetadata(const LGGOCXXSharedStoreContext& C, LGGOCXXReference *T); const uint64_t getAddressValue (void); const LGGOSimpleType getType (void) const; @@ -73,31 +73,31 @@ class LGGOCXXAddress { const LGGOCXXSharedStoreContext& getContext(void); - bool operator== (const LGGOCXXAddress& A); - bool operator> (const LGGOCXXAddress& b) const; - bool operator< (const LGGOCXXAddress& b) const; + bool operator== (const LGGOCXXReferenceMetadata& A); + bool operator> (const LGGOCXXReferenceMetadata& b) const; + bool operator< (const LGGOCXXReferenceMetadata& b) const; - LGGOCXXType * getType (void); - void setType (LGGOCXXType *T); + LGGOCXXReference * getType (void); + void setType (LGGOCXXReference *T); bool getDirty (void); void setDirty (bool D); bool getDusty (void); void setDusty (bool D); - friend class LGGOCXXSharedAddress; - friend class LGGOCXXWeakAddress; + friend class LGGOCXXSharedReference; + friend class LGGOCXXWeakReference; }; -class LGGOCXXSharedAddress { +class LGGOCXXSharedReference { private: - LGGOCXXAddress *address; + LGGOCXXReferenceMetadata *address; public: - explicit LGGOCXXSharedAddress(const LGGOCXXWeakAddress& A); - LGGOCXXSharedAddress(const LGGOCXXSharedAddress& A); - LGGOCXXSharedAddress(const LGGOCXXSharedStoreContext& C, uint64_t A); - LGGOCXXSharedAddress(const LGGOCXXSharedStoreContext& C, LGGOCXXType *T); - LGGOCXXSharedAddress(void); - ~LGGOCXXSharedAddress(void); + explicit LGGOCXXSharedReference(const LGGOCXXWeakReference& A); + LGGOCXXSharedReference(const LGGOCXXSharedReference& A); + LGGOCXXSharedReference(const LGGOCXXSharedStoreContext& C, uint64_t A); + LGGOCXXSharedReference(const LGGOCXXSharedStoreContext& C, LGGOCXXReference *T); + LGGOCXXSharedReference(void); + ~LGGOCXXSharedReference(void); bool getDirty (void); void setDirty (bool D); @@ -108,28 +108,28 @@ class LGGOCXXSharedAddress { const LGGOCXXSharedStoreContext& getContext(void); uint64_t getAddressValue(void); - LGGOCXXType * getType (void); + LGGOCXXReference * getType (void); - void setType (LGGOCXXType *T); + void setType (LGGOCXXReference *T); bool isValid (void); - LGGOCXXType * operator* (void) const; - LGGOCXXType * operator-> (void) const; + LGGOCXXReference * operator* (void) const; + LGGOCXXReference * operator-> (void) const; - LGGOCXXSharedAddress& operator= (const LGGOCXXSharedAddress& A); + LGGOCXXSharedReference& operator= (const LGGOCXXSharedReference& A); - friend class LGGOCXXWeakAddress; + friend class LGGOCXXWeakReference; }; -class LGGOCXXWeakAddress { +class LGGOCXXWeakReference { private: - LGGOCXXAddress *address; + LGGOCXXReferenceMetadata *address; public: - LGGOCXXWeakAddress(void); - explicit LGGOCXXWeakAddress(const LGGOCXXSharedAddress& A); - explicit LGGOCXXWeakAddress(LGGOCXXAddress *A); - LGGOCXXWeakAddress(const LGGOCXXWeakAddress&A); - ~LGGOCXXWeakAddress(void); + LGGOCXXWeakReference(void); + explicit LGGOCXXWeakReference(const LGGOCXXSharedReference& A); + explicit LGGOCXXWeakReference(LGGOCXXReferenceMetadata *A); + LGGOCXXWeakReference(const LGGOCXXWeakReference&A); + ~LGGOCXXWeakReference(void); bool getDirty (void); void setDirty (bool D); @@ -140,9 +140,9 @@ class LGGOCXXWeakAddress { uint64_t getAddressValue(void); bool isValid (void); - LGGOCXXWeakAddress& operator= (const LGGOCXXWeakAddress& A); + LGGOCXXWeakReference& operator= (const LGGOCXXWeakReference& A); - friend class LGGOCXXSharedAddress; + friend class LGGOCXXSharedReference; }; diff --git a/Source/Types/LGGOCXXString.cpp b/Source/Types/LGGOCXXStringRef.cpp similarity index 85% rename from Source/Types/LGGOCXXString.cpp rename to Source/Types/LGGOCXXStringRef.cpp index 0dc6725..d6282d4 100644 --- a/Source/Types/LGGOCXXString.cpp +++ b/Source/Types/LGGOCXXStringRef.cpp @@ -21,14 +21,18 @@ */ -#include "LGGOCXXString.h" +#include "LGGOCXXStringRef.h" #include #include "utf8.h" -LGGOCXXString::LGGOCXXString(std::string S) - : LGGOCXXType(), charLength(0), lengthCalculated(false) { +LGGOCXXSharedReference LGGOCXXStringRef::create(const LGGOCXXSharedStoreContext& C, std::string S) { + return LGGOCXXSharedReference (C, new LGGOCXXStringRef(S)); +} + +LGGOCXXStringRef::LGGOCXXStringRef(std::string S) + : LGGOCXXReference(), charLength(0), lengthCalculated(false) { byteLength = S.size(); if(byteLength <= 7) { @@ -52,7 +56,7 @@ LGGOCXXString::LGGOCXXString(std::string S) } } -uint64_t LGGOCXXString::getTagValue (void) { +uint64_t LGGOCXXStringRef::getTagValue (void) { uint64_t retval = 0; if (byteLength <= 7) { @@ -62,7 +66,7 @@ uint64_t LGGOCXXString::getTagValue (void) { return retval; } -uint32_t LGGOCXXString::getLength(void) { +uint32_t LGGOCXXStringRef::getLength(void) { if (lengthCalculated == false) { LGGOCXXCoreMemoryDescriptor::iterator i = stringDescriptor->begin()+1; @@ -80,7 +84,7 @@ uint32_t LGGOCXXString::getLength(void) { return charLength; } -uint16_t LGGOCXXString::getCharacterAtIndex(uint32_t index) { +uint16_t LGGOCXXStringRef::getCharacterAtIndex(uint32_t index) { uint16_t retval = 0; LGGOCXXCoreMemoryDescriptor::iterator i = stringDescriptor->begin()+1; @@ -112,6 +116,6 @@ uint16_t LGGOCXXString::getCharacterAtIndex(uint32_t index) { return retval; } -LGGOCXXSharedMemoryDescriptor LGGOCXXString::getSerializedData (void) { +LGGOCXXSharedMemoryDescriptor LGGOCXXStringRef::getSerializedData (void) { return stringDescriptor; } \ No newline at end of file diff --git a/Source/Types/LGGOCXXString.h b/Source/Types/LGGOCXXStringRef.h similarity index 88% rename from Source/Types/LGGOCXXString.h rename to Source/Types/LGGOCXXStringRef.h index 33e6cd8..c2c0251 100644 --- a/Source/Types/LGGOCXXString.h +++ b/Source/Types/LGGOCXXStringRef.h @@ -21,8 +21,8 @@ */ -#ifndef LGGOCXXSTRING_H -#define LGGOCXXSTRING_H +#ifndef LGGOCXXSTRINGREF_H +#define LGGOCXXSTRINGREF_H // Encoding // bits 0-3 string tag @@ -36,9 +36,9 @@ #include -#include "LGGOCXXType.h" +#include "LGGOCXXReference.h" -class LGGOCXXString : public LGGOCXXType { +class LGGOCXXStringRef : public LGGOCXXReference { private: LGGOCXXSharedMemoryDescriptor stringDescriptor; uint32_t charLength; @@ -46,8 +46,11 @@ class LGGOCXXString : public LGGOCXXType { uint8_t offset; bool lengthCalculated:1; bool dirty:1; + + explicit LGGOCXXStringRef(std::string S); public: - explicit LGGOCXXString(std::string S); + static LGGOCXXSharedReference create(const LGGOCXXSharedStoreContext& C, std::string S); + uint32_t getLength(void); // void getCharsInRage(uint16_t *buffer, uint32_t start, uint32_t len); uint16_t getCharacterAtIndex(uint32_t index); diff --git a/Source/objc/LGGOClass.h b/Source/objc/LGGOClass.h index 5bd1bf2..9b116cc 100644 --- a/Source/objc/LGGOClass.h +++ b/Source/objc/LGGOClass.h @@ -28,5 +28,5 @@ @interface LGGOClass : NSObject - (id) initWithName:(NSString *)name_ inContext:(LGGOGraphContext *)context_; -- (id)initWithGraphObject:(const LGGOCXXSharedAddress &)graphObject inContext:(LGGOGraphContext *)context_; +- (id)initWithGraphObject:(const LGGOCXXSharedReference &)graphObject inContext:(LGGOGraphContext *)context_; @end diff --git a/Source/objc/LGGOClass.mm b/Source/objc/LGGOClass.mm index 91ab7af..206eb8e 100644 --- a/Source/objc/LGGOClass.mm +++ b/Source/objc/LGGOClass.mm @@ -20,24 +20,24 @@ of this software and associated documentation files (the "Software"), to deal */ -#include "LGGOCXXClass.h" +#include "LGGOCXXClassRef.h" #import "LGGOGraphContext.h" #import "LGGOClass.h" @interface LGGOClass () { - LGGOCXXSharedAddress address; + LGGOCXXSharedReference address; LGGOGraphContext *graphContext; } -@property (nonatomic, readonly) LGGOCXXSharedAddress address; +@property (nonatomic, readonly) LGGOCXXSharedReference address; @end @implementation LGGOClass -- (id)initWithGraphObject:(const LGGOCXXSharedAddress &)graphObject inContext:(LGGOGraphContext *)context_ { +- (id)initWithGraphObject:(const LGGOCXXSharedReference &)graphObject inContext:(LGGOGraphContext *)context_ { self = [super init]; if (self) { @@ -54,7 +54,7 @@ - (id) initWithName:(NSString *)name_ inContext:(LGGOGraphContext *)context_ { self = [super init]; if (self) { - address = LGGOCXXSharedAddress(context_.CXXContext, new LGGOCXXClass(std::string(name_.UTF8String))); + address = LGGOCXXClassRef::create(context_.CXXContext, name_.UTF8String); graphContext = [context_ retain]; address->setNativeObject(self); } diff --git a/Source/objc/LGGOGraphContext.h b/Source/objc/LGGOGraphContext.h index 30e7a7d..f67bd66 100644 --- a/Source/objc/LGGOGraphContext.h +++ b/Source/objc/LGGOGraphContext.h @@ -26,8 +26,8 @@ #if defined __cplusplus #include "LGGOCXXStoreContext.h" -#include "LGGOCXXType.h" -#include "LGGOCXXAddress.h" +#include "LGGOCXXReference.h" +#include "LGGOCXXReferenceMetadata.h" #endif @interface LGGOGraphContext : NSObject @@ -36,8 +36,8 @@ - (id)initWithCXXContext:(const LGGOCXXSharedStoreContext&)context_; @property (copy, nonatomic) id rootObject; -- (id) transmuteToNativeObject:(LGGOCXXSharedAddress)address; -- (LGGOCXXSharedAddress) transmuteToGraphObject:(id)object; +- (id) transmuteToNativeObject:(LGGOCXXSharedReference)address; +- (LGGOCXXSharedReference) transmuteToGraphObject:(id)object; @property (nonatomic, readonly) LGGOCXXSharedStoreContext CXXContext; #endif diff --git a/Source/objc/LGGOGraphContext.mm b/Source/objc/LGGOGraphContext.mm index 17751d8..099c4a2 100644 --- a/Source/objc/LGGOGraphContext.mm +++ b/Source/objc/LGGOGraphContext.mm @@ -21,18 +21,18 @@ of this software and associated documentation files (the "Software"), to deal */ #include "LGGOCXXStoreContext.h" -#include "LGGOCXXString.h" -#include "LGGOCXXNumber.h" -#include "LGGOCXXHackArray.h" +#include "LGGOCXXStringRef.h" +#include "LGGOCXXNumberRef.h" +#include "LGGOCXXHackArrayRef.h" #import "LGGOGraphContext.h" #import "LGGOString.h" #import "LGGONumber.h" #import "LGGOMutableArray.h" -@protocol LGGOCXXSharedAddress +@protocol LGGOCXXSharedReference -@property (nonatomic, readonly) LGGOCXXSharedAddress address; +@property (nonatomic, readonly) LGGOCXXSharedReference address; @end @@ -65,21 +65,21 @@ - (void)setRootObject:(id)rootObject { // This function returns a graph object from a normal object. It will grab the underlying // graph object, or make one (without an attached native object) if necessary. -- (id) transmuteToNativeObject:(LGGOCXXSharedAddress)address { +- (id) transmuteToNativeObject:(LGGOCXXSharedReference)address { id retval = (id)(*address)->getNativeObject(); if (!retval) { - LGGOCXXHackArray *lggoArray = dynamic_cast(*address); + LGGOCXXHackArrayRef *lggoArray = dynamic_cast(*address); if (lggoArray) { return [[[LGGOMutableArray alloc] initWithGraphObject:address inContext:self] autorelease]; } - LGGOCXXString *lggoString = dynamic_cast(*address); + LGGOCXXStringRef *lggoString = dynamic_cast(*address); if (lggoString) { return [[[LGGOString alloc] initWithGraphObject:address inContext:self] autorelease]; } - LGGOCXXNumber *lggoNumber = dynamic_cast(*address); + LGGOCXXNumberRef *lggoNumber = dynamic_cast(*address); if (lggoNumber) { return [[[LGGONumber alloc] initWithGraphObject:address inContext:self] autorelease]; } @@ -88,27 +88,26 @@ - (id) transmuteToNativeObject:(LGGOCXXSharedAddress)address { return retval; } -- (LGGOCXXSharedAddress) transmuteToGraphObject:(id)object { - LGGOCXXSharedAddress retval; +- (LGGOCXXSharedReference) transmuteToGraphObject:(id)object { + LGGOCXXSharedReference retval; if ([object respondsToSelector:@selector(address)]) { - id lggoObject = object; + id lggoObject = object; retval = [lggoObject address]; retval->setNativeObject(object); } else if ([object isKindOfClass:[NSString class]]) { NSString *string = object; - retval = LGGOCXXSharedAddress(self.CXXContext, new LGGOCXXString(string.UTF8String)); + retval = LGGOCXXStringRef::create(self.CXXContext, string.UTF8String); retval->setNativeObject(object); } else if ([object isKindOfClass:[NSNumber class]]) { //FIXME this needs improvement for floats NSNumber *number = object; - LGGOCXXSharedAddress temp(self.CXXContext, new LGGOCXXNumber(number.longLongValue)); - retval = temp; + retval = LGGOCXXNumberRef::create(self.CXXContext, number.longLongValue); retval->setNativeObject(object); } else if ([object isKindOfClass:[NSArray class]]) { NSArray *array = object; - retval = LGGOCXXSharedAddress(self.CXXContext, new LGGOCXXHackArray()); - LGGOCXXHackArray *lggoArray = dynamic_cast(*retval); + retval = LGGOCXXHackArrayRef::create(self.CXXContext); + LGGOCXXHackArrayRef *lggoArray = dynamic_cast(*retval); [array enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) { lggoArray->addObject([self transmuteToGraphObject:obj]); }]; diff --git a/Source/objc/LGGOMutableArray.h b/Source/objc/LGGOMutableArray.h index 70700c0..ab99946 100644 --- a/Source/objc/LGGOMutableArray.h +++ b/Source/objc/LGGOMutableArray.h @@ -22,14 +22,14 @@ #import #if defined __cplusplus -#include "LGGOCXXAddress.h" -#include "LGGOCXXType.h" +#include "LGGOCXXReferenceMetadata.h" +#include "LGGOCXXReference.h" #endif @interface LGGOMutableArray : NSMutableArray - (id)initInContext:(LGGOGraphContext *)context_; #if defined __cplusplus -- (id)initWithGraphObject:(const LGGOCXXSharedAddress &)graphObject inContext:(LGGOGraphContext *)context_; +- (id)initWithGraphObject:(const LGGOCXXSharedReference &)graphObject inContext:(LGGOGraphContext *)context_; #endif @end diff --git a/Source/objc/LGGOMutableArray.mm b/Source/objc/LGGOMutableArray.mm index 8f10317..de4c12f 100644 --- a/Source/objc/LGGOMutableArray.mm +++ b/Source/objc/LGGOMutableArray.mm @@ -20,14 +20,14 @@ of this software and associated documentation files (the "Software"), to deal */ -#include "LGGOCXXHackArray.h" -#include "LGGOCXXObject.h" +#include "LGGOCXXHackArrayRef.h" +#include "LGGOCXXObjectRef.h" #import "LGGOGraphContext.h" #import "LGGOMutableArray.h" @interface LGGOMutableArray () { - LGGOCXXSharedAddress address; + LGGOCXXSharedReference address; LGGOGraphContext *graphContext; } @@ -35,7 +35,7 @@ @interface LGGOMutableArray () { @implementation LGGOMutableArray -- (id)initWithGraphObject:(const LGGOCXXSharedAddress &)graphObject inContext:(LGGOGraphContext *)context_ { +- (id)initWithGraphObject:(const LGGOCXXSharedReference &)graphObject inContext:(LGGOGraphContext *)context_ { self = [super init]; id retval; @@ -60,7 +60,7 @@ - (id)initInContext:(LGGOGraphContext *)context_ { self = [super init]; if (self) { - address = LGGOCXXSharedAddress(context_.CXXContext, new LGGOCXXHackArray()); + address = LGGOCXXHackArrayRef::create(context_.CXXContext); graphContext = [context_ retain]; address->setNativeObject(self); } @@ -78,11 +78,11 @@ - (void)dealloc { } - (NSUInteger)count { - return dynamic_cast(*address)->getCount(); + return dynamic_cast(*address)->getCount(); } - (id)objectAtIndex:(NSUInteger)index { - LGGOCXXSharedAddress typedObject = dynamic_cast(*address)->getObjectAtIndex(index); + LGGOCXXSharedReference typedObject = dynamic_cast(*address)->getObjectAtIndex(index); id retval = (id)typedObject->getNativeObject(); if (!retval) { @@ -93,29 +93,29 @@ - (id)objectAtIndex:(NSUInteger)index { } - (void)addObject:(id)anObject { - LGGOCXXSharedAddress objectAddress = [graphContext transmuteToGraphObject:anObject]; + LGGOCXXSharedReference objectAddress = [graphContext transmuteToGraphObject:anObject]; - dynamic_cast(*address)->addObject(objectAddress); + dynamic_cast(*address)->addObject(objectAddress); } - (void)insertObject:(id)anObject atIndex:(NSUInteger)index { - LGGOCXXSharedAddress objectAddress = [graphContext transmuteToGraphObject:anObject]; + LGGOCXXSharedReference objectAddress = [graphContext transmuteToGraphObject:anObject]; - dynamic_cast(*address)->insertObjectAtIndex(objectAddress, index); + dynamic_cast(*address)->insertObjectAtIndex(objectAddress, index); } - (void)removeLastObject { - dynamic_cast(*address)->removeLastObject(); + dynamic_cast(*address)->removeLastObject(); } - (void)removeObjectAtIndex:(NSUInteger)index { - dynamic_cast(*address)->removeObjectAtIndex(index); + dynamic_cast(*address)->removeObjectAtIndex(index); } - (void)replaceObjectAtIndex:(NSUInteger)index withObject:(id)anObject { - LGGOCXXSharedAddress objectAddress = [graphContext transmuteToGraphObject:anObject]; + LGGOCXXSharedReference objectAddress = [graphContext transmuteToGraphObject:anObject]; - dynamic_cast(*address)->replaceObjectAtIndexWithObject(objectAddress, index); + dynamic_cast(*address)->replaceObjectAtIndexWithObject(objectAddress, index); } @end diff --git a/Source/objc/LGGONumber.h b/Source/objc/LGGONumber.h index d6b7d46..3c256eb 100644 --- a/Source/objc/LGGONumber.h +++ b/Source/objc/LGGONumber.h @@ -29,6 +29,6 @@ - (id)initWithNumber:(NSNumber *)number_ inContext:(LGGOGraphContext *)context_; #if defined __cplusplus -- (id)initWithGraphObject:(const LGGOCXXSharedAddress &)graphObject inContext:(LGGOGraphContext *)context_; +- (id)initWithGraphObject:(const LGGOCXXSharedReference &)graphObject inContext:(LGGOGraphContext *)context_; #endif @end \ No newline at end of file diff --git a/Source/objc/LGGONumber.mm b/Source/objc/LGGONumber.mm index 4c9defe..1d82ef0 100644 --- a/Source/objc/LGGONumber.mm +++ b/Source/objc/LGGONumber.mm @@ -24,22 +24,22 @@ of this software and associated documentation files (the "Software"), to deal #include "LGGOGraphContext.h" -#include "LGGOCXXAddress.h" -#include "LGGOCXXNumber.h" +#include "LGGOCXXReferenceMetadata.h" +#include "LGGOCXXNumberRef.h" #import "LGGONumber.h" @interface LGGONumber () { - LGGOCXXSharedAddress address; + LGGOCXXSharedReference address; LGGOGraphContext *graphContext; } -@property LGGOCXXSharedAddress address; +@property LGGOCXXSharedReference address; @end @implementation LGGONumber -- (id)initWithGraphObject:(const LGGOCXXSharedAddress &)graphObject inContext:(LGGOGraphContext *)context_ { +- (id)initWithGraphObject:(const LGGOCXXSharedReference &)graphObject inContext:(LGGOGraphContext *)context_ { self = [super init]; id retval; @@ -49,7 +49,7 @@ - (id)initWithGraphObject:(const LGGOCXXSharedAddress &)graphObject inContext:(L id existingObject = (id)address->getNativeObject(); if (existingObject) { - address = LGGOCXXSharedAddress(); + address = LGGOCXXSharedReference(); [self release]; retval = [existingObject retain]; } else { @@ -67,13 +67,13 @@ - (id)initWithNumber:(NSNumber *)number_ inContext:(LGGOGraphContext *)context_ id retval; if (self) { - address = LGGOCXXSharedAddress(context_.CXXContext, new LGGOCXXNumber(number_.longLongValue)); + address = LGGOCXXNumberRef::create(context_.CXXContext, number_.longLongValue); id existingObject = (id)address->getNativeObject(); if (existingObject) { //We do this here so that the when the ObjC runtime destructs the C++ ivar it has an empty object to chew on - address = LGGOCXXSharedAddress(); + address = LGGOCXXSharedReference(); [self release]; retval = [existingObject retain]; } else { @@ -96,7 +96,7 @@ - (void) dealloc { } - (void)getValue:(void *)value_ { - LGGOCXXNumber *sharedNumber = dynamic_cast(*address); + LGGOCXXNumberRef *sharedNumber = dynamic_cast(*address); switch(sharedNumber->getType()) { case kLGGOCXX8BitSignedNumberType: case kLGGOCXX16BitSignedNumberType: @@ -119,7 +119,7 @@ - (void)getValue:(void *)value_ { #define LGGO_NUMBER_ACCESSOR(datatype, name) \ - (datatype)name { \ - LGGOCXXNumber *sharedNumber = dynamic_cast(*address); \ + LGGOCXXNumberRef *sharedNumber = dynamic_cast(*address); \ datatype retval; \ switch(sharedNumber->getType()) { \ case kLGGOCXX8BitSignedNumberType : \ @@ -155,7 +155,7 @@ - (datatype)name { - (const char *)objCType { const char *retval; - switch(dynamic_cast(*address)->getType()) { + switch(dynamic_cast(*address)->getType()) { case kLGGOCXX8BitSignedNumberType : retval = "c"; break; case kLGGOCXX8BitUnsignedNumberType : retval = "C"; break; case kLGGOCXX16BitSignedNumberType : retval = "i"; break; diff --git a/Source/objc/LGGOString.h b/Source/objc/LGGOString.h index 2576c12..61fbb89 100644 --- a/Source/objc/LGGOString.h +++ b/Source/objc/LGGOString.h @@ -27,6 +27,6 @@ - (id) initWithString:(NSString *)string_ inContext:(LGGOGraphContext *)context_; #if defined __cplusplus -- (id)initWithGraphObject:(const LGGOCXXSharedAddress &)graphObject inContext:(LGGOGraphContext *)context_; +- (id)initWithGraphObject:(const LGGOCXXSharedReference &)graphObject inContext:(LGGOGraphContext *)context_; #endif @end diff --git a/Source/objc/LGGOString.mm b/Source/objc/LGGOString.mm index bec624a..05368b1 100644 --- a/Source/objc/LGGOString.mm +++ b/Source/objc/LGGOString.mm @@ -21,24 +21,24 @@ of this software and associated documentation files (the "Software"), to deal */ -#include "LGGOCXXString.h" +#include "LGGOCXXStringRef.h" #import "LGGOGraphContext.h" #import "LGGOString.h" @interface LGGOString () { - LGGOCXXSharedAddress address; + LGGOCXXSharedReference address; LGGOGraphContext *graphContext; } -@property LGGOCXXSharedAddress address; +@property LGGOCXXSharedReference address; @end @implementation LGGOString -- (id)initWithGraphObject:(const LGGOCXXSharedAddress &)graphObject inContext:(LGGOGraphContext *)context_ { +- (id)initWithGraphObject:(const LGGOCXXSharedReference &)graphObject inContext:(LGGOGraphContext *)context_ { self = [super init]; id retval; @@ -64,12 +64,12 @@ - (id)initWithString:(NSString *)string_ inContext:(LGGOGraphContext *)context_ id retval; if (self) { - address = LGGOCXXSharedAddress(context_.CXXContext, new LGGOCXXString(std::string(string_.UTF8String))); + address = LGGOCXXStringRef::create(context_.CXXContext, string_.UTF8String); id existingObject = (id)address->getNativeObject(); if (existingObject) { - address = LGGOCXXSharedAddress(); + address = LGGOCXXSharedReference(); [self release]; retval = [existingObject retain]; } else { @@ -92,16 +92,16 @@ - (void) dealloc { } - (NSUInteger)length { - return dynamic_cast(*address)->getLength(); + return dynamic_cast(*address)->getLength(); } - (unichar)characterAtIndex:(NSUInteger)index { - return dynamic_cast(*address)->getCharacterAtIndex(index); + return dynamic_cast(*address)->getCharacterAtIndex(index); } #if 0 - (void)getCharacters:(unichar *)buffer range:(NSRange)aRange { - std::tr1::dynamic_pointer_cast(sharedType)->getCharsInRage(buffer, aRange.location, aRange.length); + std::tr1::dynamic_pointer_cast(sharedType)->getCharsInRage(buffer, aRange.location, aRange.length); } #endif diff --git a/TODO b/TODO index c020bfe..da8a770 100644 --- a/TODO +++ b/TODO @@ -3,7 +3,7 @@ CXX Turn LGGOAddress into a smart pointer and eliminate all the shared pointer and address maps Convert all container interfaces into STL compatible interfaces Get B+Tree based collections running - Remove LGGOCXXHackArray + Remove LGGOCXXHackArrayRef Remove the strong maps in LGGOCXXContext ObjC From 070d2bf234a8ef6bae07c6acfafd8c083a555ce1 Mon Sep 17 00:00:00 2001 From: Louis Gerbarg Date: Fri, 12 Nov 2010 23:14:43 -0800 Subject: [PATCH 9/9] Big smart pointer improvements Lots of renames and refactoring to make things a bit more comprehensible Workarounds for compiler bugs (still leaking smart pointer metadata, but not actual objects) --- GraphObjects.xcodeproj/project.pbxproj | 2 + Source/Storage/LGGOCXXStoreContext.cpp | 38 +++- Source/Storage/LGGOCXXStoreContext.h | 11 +- .../HackArray/LGGOCXXHackArrayRef.cpp | 4 - .../HackArray/LGGOCXXHackArrayRef.h | 6 +- Source/Types/LGGOCXXClassRef.cpp | 4 - Source/Types/LGGOCXXClassRef.h | 6 +- Source/Types/LGGOCXXNumberRef.cpp | 6 +- Source/Types/LGGOCXXNumberRef.h | 6 +- Source/Types/LGGOCXXReference.cpp | 10 +- Source/Types/LGGOCXXReference.h | 6 +- Source/Types/LGGOCXXReferenceMetadata.cpp | 191 +++++++++--------- Source/Types/LGGOCXXReferenceMetadata.h | 33 +-- Source/Types/LGGOCXXStringRef.cpp | 4 - Source/Types/LGGOCXXStringRef.h | 3 +- Source/objc/LGGOClass.mm | 19 +- Source/objc/LGGOGraph.mm | 3 +- Source/objc/LGGOGraphContext.mm | 6 +- Source/objc/LGGOMutableArray.mm | 36 ++-- Source/objc/LGGONumber.mm | 38 ++-- Source/objc/LGGOString.mm | 30 +-- Tests/LGGOStringTests.m | 5 - 22 files changed, 256 insertions(+), 211 deletions(-) diff --git a/GraphObjects.xcodeproj/project.pbxproj b/GraphObjects.xcodeproj/project.pbxproj index 351093a..7e7b3da 100644 --- a/GraphObjects.xcodeproj/project.pbxproj +++ b/GraphObjects.xcodeproj/project.pbxproj @@ -495,6 +495,7 @@ buildSettings = { ARCHS = "$(ARCHS_STANDARD_64_BIT)"; GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_ENABLE_CPP_RTTI = YES; GCC_OPTIMIZATION_LEVEL = 0; GCC_PREPROCESSOR_DEFINITIONS = DEBUG; GCC_VERSION = com.apple.compilers.llvm.clang.1_0; @@ -512,6 +513,7 @@ buildSettings = { ARCHS = "$(ARCHS_STANDARD_64_BIT)"; GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_ENABLE_CPP_RTTI = YES; GCC_VERSION = com.apple.compilers.llvm.clang.1_0; GCC_WARN_ABOUT_RETURN_TYPE = YES; GCC_WARN_UNUSED_VARIABLE = YES; diff --git a/Source/Storage/LGGOCXXStoreContext.cpp b/Source/Storage/LGGOCXXStoreContext.cpp index eca6eeb..aad6413 100644 --- a/Source/Storage/LGGOCXXStoreContext.cpp +++ b/Source/Storage/LGGOCXXStoreContext.cpp @@ -31,6 +31,13 @@ #include "LGGOCXXStoreSegment.h" #include "LGGOCXXMemoryDescriptor.h" +#include "LGGOCXXStringRef.h" +#include "LGGOCXXNumberRef.h" + +#include "LGGOCXXClassRef.h" + +#include "LGGOCXXHackArrayRef.h" + #include "LGGOCXXStoreContext.h" LGGOCXXStoreContext::LGGOCXXStoreContext(const LGGOCXXSharedStore &S) @@ -43,6 +50,24 @@ uint64_t LGGOCXXStoreContext::getNextFreeAddress (void) { return retval; } +LGGOCXXSharedReference LGGOCXXStoreContext::createArray(void) { + return LGGOCXXSharedReference(shared_from_this(), new LGGOCXXHackArrayRef()); +} + +LGGOCXXSharedReference LGGOCXXStoreContext::createString(std::string S) { + return LGGOCXXSharedReference (shared_from_this(), new LGGOCXXStringRef(S)); +} + +LGGOCXXSharedReference LGGOCXXStoreContext::createNumber(int64_t N) { + return LGGOCXXSharedReference (shared_from_this(), new LGGOCXXNumberRef(N)); +} + + +LGGOCXXSharedReference LGGOCXXStoreContext::createClass(std::string C) { + return LGGOCXXSharedReference (shared_from_this(), new LGGOCXXClassRef(C)); +} + + //FIXME implement transient save here void LGGOCXXStoreContext::writeSegment (void) { @@ -72,16 +97,16 @@ void LGGOCXXStoreContext::commit (void) { } LGGOCXXReference * LGGOCXXStoreContext::rootObject(void) { - LGGOCXXSharedReference address(getAddress(1<<4)); + LGGOCXXSharedReference address(getReferenceForAddress(1<<4)); return *address; } void LGGOCXXStoreContext::setRootObject(LGGOCXXReference *T) { LGGOCXXSharedReference address(shared_from_this(), 1<<4); - address.setType(T); + address.setReference(T); } -LGGOCXXSharedReference LGGOCXXStoreContext::getAddress (uint64_t address) { +LGGOCXXSharedReference LGGOCXXStoreContext::getReferenceForAddress (uint64_t address) { std::map::iterator i = addresses.find(address); if (i == addresses.end()) { @@ -89,14 +114,13 @@ LGGOCXXSharedReference LGGOCXXStoreContext::getAddress (uint64_t address) { } else { assert(0); LGGOCXXSharedReference retval = LGGOCXXSharedReference(shared_from_this(), address); - setAddressForAddressValue(LGGOCXXWeakReference(retval), address); + setReferenceForAddress(LGGOCXXWeakReference(retval), address); return retval; } }; -void LGGOCXXStoreContext::setAddressForAddressValue(const LGGOCXXWeakReference& address, uint64_t addressValue) { -// addresses[addressValue] = address; - addresses.insert(std::pair(addressValue, address)); +void LGGOCXXStoreContext::setReferenceForAddress(const LGGOCXXWeakReference& reference, uint64_t address) { + addresses.insert(std::pair(address, reference)); } LGGOCXXSharedReference LGGOCXXStoreContext::getAddressForAddressValue(uint64_t addressValue) { diff --git a/Source/Storage/LGGOCXXStoreContext.h b/Source/Storage/LGGOCXXStoreContext.h index c1ce73e..d7ffd9d 100644 --- a/Source/Storage/LGGOCXXStoreContext.h +++ b/Source/Storage/LGGOCXXStoreContext.h @@ -55,17 +55,24 @@ class LGGOCXXStoreContext : public std::tr1::enable_shared_from_this objects; LGGOCXXHackArrayRef(void) : LGGOCXXReference() { } -public: - static LGGOCXXSharedReference create (const LGGOCXXSharedStoreContext& C); - +public: uint64_t getCount(void); LGGOCXXSharedReference getObjectAtIndex(uint64_t i); @@ -51,4 +49,6 @@ class LGGOCXXHackArrayRef : public LGGOCXXReference { virtual uint64_t getTagValue (void); virtual LGGOCXXSharedMemoryDescriptor getSerializedData (void); + + friend LGGOCXXSharedReference LGGOCXXStoreContext::createArray(void); }; \ No newline at end of file diff --git a/Source/Types/LGGOCXXClassRef.cpp b/Source/Types/LGGOCXXClassRef.cpp index e967850..8e93361 100644 --- a/Source/Types/LGGOCXXClassRef.cpp +++ b/Source/Types/LGGOCXXClassRef.cpp @@ -23,10 +23,6 @@ #include "LGGOCXXClassRef.h" -LGGOCXXSharedReference LGGOCXXClassRef::create(const LGGOCXXSharedStoreContext& C, std::string S) { - return LGGOCXXSharedReference (C, new LGGOCXXClassRef(S)); -} - LGGOCXXClassRef::LGGOCXXClassRef(std::string N) : LGGOCXXReference(), name(N) { } diff --git a/Source/Types/LGGOCXXClassRef.h b/Source/Types/LGGOCXXClassRef.h index 5a3d083..6dd29ef 100644 --- a/Source/Types/LGGOCXXClassRef.h +++ b/Source/Types/LGGOCXXClassRef.h @@ -42,9 +42,7 @@ class LGGOCXXClassRef : public LGGOCXXReference { bool dirty:1; explicit LGGOCXXClassRef(std::string N); -public: - static LGGOCXXSharedReference create(const LGGOCXXSharedStoreContext& C, std::string S); - +public: void addProperty(std::string name, LGGOCXXScalarEncodingType type); void addRelation(std::string name, LGGOCXXRelationEncodingType type, LGGOCXXRelationSemanticsType semantics); @@ -57,6 +55,8 @@ class LGGOCXXClassRef : public LGGOCXXReference { virtual uint64_t getTagValue (void); virtual LGGOCXXSharedMemoryDescriptor getSerializedData (void); + + friend LGGOCXXSharedReference LGGOCXXStoreContext::createClass(std::string C); }; #endif \ No newline at end of file diff --git a/Source/Types/LGGOCXXNumberRef.cpp b/Source/Types/LGGOCXXNumberRef.cpp index f96cf23..1145d13 100644 --- a/Source/Types/LGGOCXXNumberRef.cpp +++ b/Source/Types/LGGOCXXNumberRef.cpp @@ -27,10 +27,6 @@ #define LGGO_MAX_INT59 ((int64_t)0x03ffffffffffffff) #define LGGO_MIN_INT59 ((int64_t)(-1*LGGO_MAX_INT59)) -LGGOCXXSharedReference LGGOCXXNumberRef::create(const LGGOCXXSharedStoreContext& C, int64_t N) { - return LGGOCXXSharedReference (C, new LGGOCXXNumberRef(N)); -} - LGGOCXXNumberRef::LGGOCXXNumberRef(int64_t N) : LGGOCXXReference(), rawValue(N) { rawValue = *((uint64_t *)&N); @@ -66,7 +62,7 @@ LGGOCXXNumberRef::LGGOCXXNumberRef(int64_t N) : LGGOCXXReference(), rawValue(N) } } -LGGOCXXScalarEncodingType LGGOCXXNumberRef::getType(void) { +LGGOCXXScalarEncodingType LGGOCXXNumberRef::getNumberType(void) { return type; } diff --git a/Source/Types/LGGOCXXNumberRef.h b/Source/Types/LGGOCXXNumberRef.h index 8c92ceb..6d60c50 100644 --- a/Source/Types/LGGOCXXNumberRef.h +++ b/Source/Types/LGGOCXXNumberRef.h @@ -49,10 +49,8 @@ class LGGOCXXNumberRef : public LGGOCXXReference { explicit LGGOCXXNumberRef(int64_t N); public: - static LGGOCXXSharedReference create(const LGGOCXXSharedStoreContext& C, int64_t N); - - LGGOCXXScalarEncodingType getType(void); + LGGOCXXScalarEncodingType getNumberType(void); int64_t signedValue (void); uint64_t unsignedValue (void); float floatValue(void); @@ -60,6 +58,8 @@ class LGGOCXXNumberRef : public LGGOCXXReference { virtual uint64_t getTagValue (void); virtual LGGOCXXSharedMemoryDescriptor getSerializedData (void); + + friend LGGOCXXSharedReference LGGOCXXStoreContext::createNumber(int64_t N); }; #endif \ No newline at end of file diff --git a/Source/Types/LGGOCXXReference.cpp b/Source/Types/LGGOCXXReference.cpp index b7241d1..dff3ec4 100644 --- a/Source/Types/LGGOCXXReference.cpp +++ b/Source/Types/LGGOCXXReference.cpp @@ -26,12 +26,12 @@ LGGOCXXReference::LGGOCXXReference(void) : clientData(NULL) { } -LGGOCXXWeakReference LGGOCXXReference::getAddress(void) { - return address; +LGGOCXXWeakReference LGGOCXXReference::getMetadata(void) { + return metadata; } -void LGGOCXXReference::setAddress (const LGGOCXXWeakReference &A) { - address = A; +void LGGOCXXReference::setMetadata (const LGGOCXXWeakReference &R) { + metadata = R; } void *LGGOCXXReference::getNativeObject(void) { @@ -39,7 +39,7 @@ void *LGGOCXXReference::getNativeObject(void) { } const LGGOCXXSharedStoreContext &LGGOCXXReference::getContext(void) { - return address.getContext(); + return metadata.getContext(); } void LGGOCXXReference::setNativeObject(void *D) { diff --git a/Source/Types/LGGOCXXReference.h b/Source/Types/LGGOCXXReference.h index c6e021c..c1847c7 100644 --- a/Source/Types/LGGOCXXReference.h +++ b/Source/Types/LGGOCXXReference.h @@ -66,13 +66,13 @@ typedef enum { class LGGOCXXReference { private: - LGGOCXXWeakReference address; + LGGOCXXWeakReference metadata; void *clientData; public: explicit LGGOCXXReference(void); - LGGOCXXWeakReference getAddress(void); - void setAddress (const LGGOCXXWeakReference &A); + LGGOCXXWeakReference getMetadata(void); + void setMetadata (const LGGOCXXWeakReference &R); const LGGOCXXSharedStoreContext& getContext(void); diff --git a/Source/Types/LGGOCXXReferenceMetadata.cpp b/Source/Types/LGGOCXXReferenceMetadata.cpp index 757be5c..32346f8 100644 --- a/Source/Types/LGGOCXXReferenceMetadata.cpp +++ b/Source/Types/LGGOCXXReferenceMetadata.cpp @@ -54,26 +54,26 @@ #pragma mark - #pragma mark Control Block Implementation -LGGOCXXReferenceMetadata::LGGOCXXReferenceMetadata(const LGGOCXXSharedStoreContext& C, LGGOCXXReference *T) - : context(C), strongRefCount(0), weakRefCount(0), dirty(false), dusty(false), type(T) { +LGGOCXXReferenceMetadata::LGGOCXXReferenceMetadata(const LGGOCXXSharedStoreContext& C, LGGOCXXReference *R) + : context(C), strongRefCount(0), weakRefCount(0), dirty(false), dusty(false), reference(R) { //Weak declare this weakAddr at top of scope to guarantee the addr is not deleted during setup LGGOCXXWeakReference weakAddr(this); - T->setAddress(weakAddr); - address = context->getNextFreeAddress(); - context->setAddressForAddressValue(LGGOCXXWeakReference(this), address); + R->setMetadata(weakAddr); + address = C->getNextFreeAddress(); + C->setReferenceForAddress(LGGOCXXWeakReference(this), address); LG_LOG("Create 0x%llx real address\n", getAddressValue()); - assert(type->getAddress().getAddressValue() == address); + assert(reference->getMetadata().getAddressValue() == address); } -LGGOCXXReferenceMetadata::LGGOCXXReferenceMetadata(const LGGOCXXSharedStoreContext& C, LGGOCXXReference *T, uint64_t A) - : context(C), strongRefCount(0), weakRefCount(0), dirty(false), dusty(false), type(T), address(A) { +LGGOCXXReferenceMetadata::LGGOCXXReferenceMetadata(const LGGOCXXSharedStoreContext& C, LGGOCXXReference *R, uint64_t A) + : context(C), strongRefCount(0), weakRefCount(0), dirty(false), dusty(false), reference(R), address(A) { //Weak declare this weakAddr at top of scope to guarantee the addr is not deleted during setup LGGOCXXWeakReference weakAddr(this); - T->setAddress(weakAddr); - context->setAddressForAddressValue(LGGOCXXWeakReference(this), address); + R->setMetadata(weakAddr); + C->setReferenceForAddress(LGGOCXXWeakReference(this), address); LG_LOG("Create 0x%llx real address\n", getAddressValue()); - assert(type->getAddress().getAddressValue() == address); - assert(type->getAddress().getAddressValue() == A); + assert(reference->getMetadata().getAddressValue() == address); + assert(reference->getMetadata().getAddressValue() == A); } const uint64_t LGGOCXXReferenceMetadata::getAddressValue (void) { @@ -109,8 +109,12 @@ void LGGOCXXReferenceMetadata::decrementStrongCount (void) { assert(strongRefCount > 0); strongRefCount--; - if (strongRefCount == 0 && weakRefCount == 0) { - delete this; + if (strongRefCount == 0) { + delete reference; + + if (weakRefCount == 0) { +// delete this; + } } } @@ -132,8 +136,8 @@ void LGGOCXXReferenceMetadata::decrementWeakCount (void) { } -bool LGGOCXXReferenceMetadata::operator== (const LGGOCXXReferenceMetadata& A) { - return (address == A.address); +bool LGGOCXXReferenceMetadata::operator== (const LGGOCXXReferenceMetadata& R) { + return (address == R.address); } bool LGGOCXXReferenceMetadata::operator> (const LGGOCXXReferenceMetadata& b) const { @@ -144,16 +148,21 @@ bool LGGOCXXReferenceMetadata::operator< (const LGGOCXXReferenceMetadata& b) con return address < b.address; } -const LGGOCXXSharedStoreContext& LGGOCXXReferenceMetadata::getContext(void) { - return context; +LGGOCXXSharedStoreContext LGGOCXXReferenceMetadata::getContext(void) { + if (context.expired()) { + return LGGOCXXSharedStoreContext(); + } else { + return LGGOCXXSharedStoreContext(context); + + } } -LGGOCXXReference * LGGOCXXReferenceMetadata::getType (void) { - return type; +LGGOCXXReference * LGGOCXXReferenceMetadata::getReference (void) { + return reference; } -void LGGOCXXReferenceMetadata::setType (LGGOCXXReference *T) { - type = T; +void LGGOCXXReferenceMetadata::setReference (LGGOCXXReference *R) { + reference = R; } bool LGGOCXXReferenceMetadata::getDirty (void) { @@ -173,37 +182,37 @@ void LGGOCXXReferenceMetadata::setDusty (bool D) { } bool LGGOCXXSharedReference::getDirty (void) { - return address->getDirty(); + return metadata->getDirty(); } void LGGOCXXSharedReference::setDirty (bool D) { - address->setDirty(D); + metadata->setDirty(D); } bool LGGOCXXSharedReference::getDusty (void) { - return address->getDusty(); + return metadata->getDusty(); } void LGGOCXXSharedReference::setDusty (bool D) { - address->setDusty(D); + metadata->setDusty(D); } #pragma mark - #pragma mark Strong Pointer Implementation -LGGOCXXSharedReference::LGGOCXXSharedReference(void) : address(NULL) { +LGGOCXXSharedReference::LGGOCXXSharedReference(void) : metadata(NULL) { //printf("Create NULL strong address\n"); } -LGGOCXXSharedReference::LGGOCXXSharedReference(const LGGOCXXWeakReference& A) : address(A.address) { - if (address) { - address->incrementStrongCount(); +LGGOCXXSharedReference::LGGOCXXSharedReference(const LGGOCXXWeakReference& R) : metadata(R.metadata) { + if (metadata) { + metadata->incrementStrongCount(); } } -LGGOCXXSharedReference::LGGOCXXSharedReference(const LGGOCXXSharedReference& A) : address(A.address) { - if (address) { - address->incrementStrongCount(); +LGGOCXXSharedReference::LGGOCXXSharedReference(const LGGOCXXSharedReference& R) : metadata(R.metadata) { + if (metadata) { + metadata->incrementStrongCount(); } } @@ -211,12 +220,12 @@ LGGOCXXSharedReference::LGGOCXXSharedReference(const LGGOCXXSharedStoreContext& assert(A != 0); LGGOCXXSharedReference existingAddress = C->getAddressForAddressValue(A); if (existingAddress.isValid()) { - address = existingAddress.address; - address->incrementStrongCount(); + metadata = existingAddress.metadata; + metadata->incrementStrongCount(); } else { assert(0); } - assert(address->getAddressValue() == A); + assert(metadata->getAddressValue() == A); //printf("Create 0x%llx strong address\n", address->getAddressValue()); } @@ -226,66 +235,66 @@ LGGOCXXSharedReference::LGGOCXXSharedReference(const LGGOCXXSharedStoreContext& if (tagValue) { LGGOCXXSharedReference existingAddress = C->getAddressForAddressValue(tagValue); if (existingAddress.isValid()) { - address = existingAddress.address; + metadata = existingAddress.metadata; } else { - address = new LGGOCXXReferenceMetadata(C, T, tagValue); + metadata = new LGGOCXXReferenceMetadata(C, T, tagValue); } - assert(address->getAddressValue() == tagValue); + assert(metadata->getAddressValue() == tagValue); //printf("Create 0x%llx strong address\n", address->getAddressValue()); } else { - address = new LGGOCXXReferenceMetadata(C, T); + metadata = new LGGOCXXReferenceMetadata(C, T); } - address->incrementStrongCount(); + metadata->incrementStrongCount(); //printf("Create 0x%llx strong address\n", address->getAddressValue()); } LGGOCXXSharedReference::~LGGOCXXSharedReference(void) { - if (address) { - address->decrementStrongCount(); + if (metadata) { + metadata->decrementStrongCount(); } } -const LGGOCXXSharedStoreContext& LGGOCXXSharedReference::getContext(void) { - assert(address != NULL); - return address->getContext(); +LGGOCXXSharedStoreContext LGGOCXXSharedReference::getContext(void) { + assert(metadata != NULL); + return metadata->getContext(); } uint64_t LGGOCXXSharedReference::getAddressValue(void) { - return address->getAddressValue(); + return metadata->getAddressValue(); } -LGGOCXXReference *LGGOCXXSharedReference::getType (void) { - assert(address != NULL); - return address->getType(); +LGGOCXXReference *LGGOCXXSharedReference::getReference (void) { + assert(metadata != NULL); + return metadata->getReference(); } -void LGGOCXXSharedReference::setType (LGGOCXXReference *T) { - assert(address != NULL); - address->setType(T); +void LGGOCXXSharedReference::setReference (LGGOCXXReference *R) { + assert(metadata != NULL); + metadata->setReference(R); } bool LGGOCXXSharedReference::isValid (void) { - return (address != NULL); + return (metadata != NULL); } LGGOCXXReference *LGGOCXXSharedReference::operator* (void) const { - assert(address != NULL); - return address->getType(); + assert(metadata != NULL); + return metadata->getReference(); } LGGOCXXReference *LGGOCXXSharedReference::operator-> (void) const { - assert(address != NULL); - return address->getType(); + assert(metadata != NULL); + return metadata->getReference(); } -LGGOCXXSharedReference& LGGOCXXSharedReference::operator= (const LGGOCXXSharedReference& A) { - if (address) { - address->decrementStrongCount(); +LGGOCXXSharedReference& LGGOCXXSharedReference::operator= (const LGGOCXXSharedReference& R) { + if (metadata) { + metadata->decrementStrongCount(); } - address = A.address; - if (address) { - address->incrementStrongCount(); + metadata = R.metadata; + if (metadata) { + metadata->incrementStrongCount(); } return *this; } @@ -293,72 +302,72 @@ LGGOCXXSharedReference& LGGOCXXSharedReference::operator= (const LGGOCXXSharedRe #pragma mark - #pragma mark Weak Pointer Implementation -LGGOCXXWeakReference::LGGOCXXWeakReference(void) : address(NULL) { +LGGOCXXWeakReference::LGGOCXXWeakReference(void) : metadata(NULL) { // printf("Create NULL weak address\n"); } -LGGOCXXWeakReference::LGGOCXXWeakReference(LGGOCXXReferenceMetadata *A) : address(A) { +LGGOCXXWeakReference::LGGOCXXWeakReference(LGGOCXXReferenceMetadata *MD) : metadata(MD) { // printf("Create 0x%llx weak address\n", A->getAddressValue()); - if (address) { - address->incrementWeakCount(); + if (metadata) { + metadata->incrementWeakCount(); } } -LGGOCXXWeakReference::LGGOCXXWeakReference(const LGGOCXXWeakReference& A) : address(A.address) { - if (address) { - address->incrementWeakCount(); +LGGOCXXWeakReference::LGGOCXXWeakReference(const LGGOCXXWeakReference& MD) : metadata(MD.metadata) { + if (metadata) { + metadata->incrementWeakCount(); } } -LGGOCXXWeakReference::LGGOCXXWeakReference(const LGGOCXXSharedReference& A) : address(A.address) { - if (address) { - address->incrementWeakCount(); +LGGOCXXWeakReference::LGGOCXXWeakReference(const LGGOCXXSharedReference& MD) : metadata(MD.metadata) { + if (metadata) { + metadata->incrementWeakCount(); } } LGGOCXXWeakReference::~LGGOCXXWeakReference(void) { - if (address) { - address->decrementWeakCount(); + if (metadata) { + metadata->decrementWeakCount(); } } -const LGGOCXXSharedStoreContext& LGGOCXXWeakReference::getContext(void) { - assert(address != NULL); - return address->getContext(); +LGGOCXXSharedStoreContext LGGOCXXWeakReference::getContext(void) { + assert(metadata != NULL); + return metadata->getContext(); } uint64_t LGGOCXXWeakReference::getAddressValue(void) { - return address->getAddressValue(); + return metadata->getAddressValue(); } bool LGGOCXXWeakReference::isValid (void) { - return (address != NULL); + return (metadata != NULL); } -LGGOCXXWeakReference& LGGOCXXWeakReference::operator= (const LGGOCXXWeakReference& A) { - if (address) { - address->decrementWeakCount(); +LGGOCXXWeakReference& LGGOCXXWeakReference::operator= (const LGGOCXXWeakReference& R) { + if (metadata) { + metadata->decrementWeakCount(); } - address = A.address; - if (address) { - address->incrementWeakCount(); + metadata = R.metadata; + if (metadata) { + metadata->incrementWeakCount(); } return *this; } bool LGGOCXXWeakReference::getDirty (void) { - return address->getDirty(); + return metadata->getDirty(); } void LGGOCXXWeakReference::setDirty (bool D) { - address->setDirty(D); + metadata->setDirty(D); } bool LGGOCXXWeakReference::getDusty (void) { - return address->getDusty(); + return metadata->getDusty(); } void LGGOCXXWeakReference::setDusty (bool D) { - address->setDusty(D); + metadata->setDusty(D); } diff --git a/Source/Types/LGGOCXXReferenceMetadata.h b/Source/Types/LGGOCXXReferenceMetadata.h index c0a742b..1699ff6 100644 --- a/Source/Types/LGGOCXXReferenceMetadata.h +++ b/Source/Types/LGGOCXXReferenceMetadata.h @@ -38,7 +38,10 @@ typedef enum { kLGGOAddressStringType = 4, kLGGOAddressDateType = 5, kLGGOAddressArrayType = 6, - kLGGOAddressComplexType = 15 + kLGGOAddressComplexType = 15, + kLGGOAddressMutableArray = (kLGGOAddressComplexType | 1<<4), + kLGGOAddressMutableSet = (kLGGOAddressComplexType | 2<<4), + kLGGOAddressMutableDictionary = (kLGGOAddressComplexType | 3<<4) } LGGOSimpleType; #include @@ -48,15 +51,16 @@ typedef enum { class LGGOCXXReferenceMetadata { private: uint64_t address; - LGGOCXXSharedStoreContext context; - LGGOCXXReference *type; + LGGOCXXWeakStoreContext context; + LGGOCXXReference *reference; uint32_t strongRefCount; uint32_t weakRefCount; bool dirty:1; bool dusty:1; + public: - explicit LGGOCXXReferenceMetadata(const LGGOCXXSharedStoreContext& C, LGGOCXXReference *T, uint64_t A); - explicit LGGOCXXReferenceMetadata(const LGGOCXXSharedStoreContext& C, LGGOCXXReference *T); + explicit LGGOCXXReferenceMetadata(const LGGOCXXSharedStoreContext& C, LGGOCXXReference *R, uint64_t A); + explicit LGGOCXXReferenceMetadata(const LGGOCXXSharedStoreContext& C, LGGOCXXReference *R); const uint64_t getAddressValue (void); const LGGOSimpleType getType (void) const; @@ -71,14 +75,14 @@ class LGGOCXXReferenceMetadata { void incrementWeakCount (void); void decrementWeakCount (void); - const LGGOCXXSharedStoreContext& getContext(void); + LGGOCXXSharedStoreContext getContext(void); bool operator== (const LGGOCXXReferenceMetadata& A); bool operator> (const LGGOCXXReferenceMetadata& b) const; bool operator< (const LGGOCXXReferenceMetadata& b) const; - LGGOCXXReference * getType (void); - void setType (LGGOCXXReference *T); + LGGOCXXReference * getReference (void); + void setReference (LGGOCXXReference *R); bool getDirty (void); void setDirty (bool D); @@ -88,9 +92,10 @@ class LGGOCXXReferenceMetadata { friend class LGGOCXXSharedReference; friend class LGGOCXXWeakReference; }; + class LGGOCXXSharedReference { private: - LGGOCXXReferenceMetadata *address; + LGGOCXXReferenceMetadata *metadata; public: explicit LGGOCXXSharedReference(const LGGOCXXWeakReference& A); LGGOCXXSharedReference(const LGGOCXXSharedReference& A); @@ -105,12 +110,12 @@ class LGGOCXXSharedReference { void setDusty (bool D); - const LGGOCXXSharedStoreContext& getContext(void); + LGGOCXXSharedStoreContext getContext(void); uint64_t getAddressValue(void); - LGGOCXXReference * getType (void); + LGGOCXXReference * getReference (void); - void setType (LGGOCXXReference *T); + void setReference (LGGOCXXReference *T); bool isValid (void); LGGOCXXReference * operator* (void) const; @@ -123,7 +128,7 @@ class LGGOCXXSharedReference { class LGGOCXXWeakReference { private: - LGGOCXXReferenceMetadata *address; + LGGOCXXReferenceMetadata *metadata; public: LGGOCXXWeakReference(void); explicit LGGOCXXWeakReference(const LGGOCXXSharedReference& A); @@ -136,7 +141,7 @@ class LGGOCXXWeakReference { bool getDusty (void); void setDusty (bool D); - const LGGOCXXSharedStoreContext& getContext(void); + LGGOCXXSharedStoreContext getContext(void); uint64_t getAddressValue(void); bool isValid (void); diff --git a/Source/Types/LGGOCXXStringRef.cpp b/Source/Types/LGGOCXXStringRef.cpp index d6282d4..f0cce83 100644 --- a/Source/Types/LGGOCXXStringRef.cpp +++ b/Source/Types/LGGOCXXStringRef.cpp @@ -26,10 +26,6 @@ #include #include "utf8.h" - -LGGOCXXSharedReference LGGOCXXStringRef::create(const LGGOCXXSharedStoreContext& C, std::string S) { - return LGGOCXXSharedReference (C, new LGGOCXXStringRef(S)); -} LGGOCXXStringRef::LGGOCXXStringRef(std::string S) : LGGOCXXReference(), charLength(0), lengthCalculated(false) { diff --git a/Source/Types/LGGOCXXStringRef.h b/Source/Types/LGGOCXXStringRef.h index c2c0251..120954c 100644 --- a/Source/Types/LGGOCXXStringRef.h +++ b/Source/Types/LGGOCXXStringRef.h @@ -49,7 +49,6 @@ class LGGOCXXStringRef : public LGGOCXXReference { explicit LGGOCXXStringRef(std::string S); public: - static LGGOCXXSharedReference create(const LGGOCXXSharedStoreContext& C, std::string S); uint32_t getLength(void); // void getCharsInRage(uint16_t *buffer, uint32_t start, uint32_t len); @@ -57,6 +56,8 @@ class LGGOCXXStringRef : public LGGOCXXReference { virtual uint64_t getTagValue (void); virtual LGGOCXXSharedMemoryDescriptor getSerializedData (void); + + friend LGGOCXXSharedReference LGGOCXXStoreContext::createString(std::string S); }; #endif \ No newline at end of file diff --git a/Source/objc/LGGOClass.mm b/Source/objc/LGGOClass.mm index 206eb8e..c347c6f 100644 --- a/Source/objc/LGGOClass.mm +++ b/Source/objc/LGGOClass.mm @@ -27,11 +27,11 @@ of this software and associated documentation files (the "Software"), to deal #import "LGGOClass.h" @interface LGGOClass () { - LGGOCXXSharedReference address; + LGGOCXXSharedReference reference; LGGOGraphContext *graphContext; } -@property (nonatomic, readonly) LGGOCXXSharedReference address; +@property (nonatomic, readonly) LGGOCXXSharedReference reference; @end @@ -41,9 +41,9 @@ - (id)initWithGraphObject:(const LGGOCXXSharedReference &)graphObject inContext: self = [super init]; if (self) { - address = graphObject; + reference = graphObject; graphContext = [context_ retain]; - address->setNativeObject(self); + reference->setNativeObject(self); } return self; @@ -54,16 +54,21 @@ - (id) initWithName:(NSString *)name_ inContext:(LGGOGraphContext *)context_ { self = [super init]; if (self) { - address = LGGOCXXClassRef::create(context_.CXXContext, name_.UTF8String); + { + //LLVM/Clang 2.8 compiler bug work around + LGGOCXXSharedStoreContext context = context_.CXXContext; + reference = context->createClass(name_.UTF8String); + } + graphContext = [context_ retain]; - address->setNativeObject(self); + reference->setNativeObject(self); } return self; } - (void) dealloc { - address->setNativeObject(NULL); + reference->setNativeObject(NULL); [graphContext release]; [super dealloc]; diff --git a/Source/objc/LGGOGraph.mm b/Source/objc/LGGOGraph.mm index 728da6a..1922375 100644 --- a/Source/objc/LGGOGraph.mm +++ b/Source/objc/LGGOGraph.mm @@ -55,8 +55,7 @@ - (void)dealloc { - (LGGOGraphContext *)newContext { LGGOCXXSharedStoreContext context = LGGOCXXSharedStoreContext(store->newContext()); - LGGOGraphContext *retval = [[LGGOGraphContext alloc] initWithCXXContext:context]; - return retval; + return [[LGGOGraphContext alloc] initWithCXXContext:context]; } @end diff --git a/Source/objc/LGGOGraphContext.mm b/Source/objc/LGGOGraphContext.mm index 099c4a2..6db74c9 100644 --- a/Source/objc/LGGOGraphContext.mm +++ b/Source/objc/LGGOGraphContext.mm @@ -97,16 +97,16 @@ - (LGGOCXXSharedReference) transmuteToGraphObject:(id)object { retval->setNativeObject(object); } else if ([object isKindOfClass:[NSString class]]) { NSString *string = object; - retval = LGGOCXXStringRef::create(self.CXXContext, string.UTF8String); + retval = self.CXXContext->createString(string.UTF8String); retval->setNativeObject(object); } else if ([object isKindOfClass:[NSNumber class]]) { //FIXME this needs improvement for floats NSNumber *number = object; - retval = LGGOCXXNumberRef::create(self.CXXContext, number.longLongValue); + retval = self.CXXContext->createNumber(number.longLongValue); retval->setNativeObject(object); } else if ([object isKindOfClass:[NSArray class]]) { NSArray *array = object; - retval = LGGOCXXHackArrayRef::create(self.CXXContext); + retval = self.CXXContext->createArray(); LGGOCXXHackArrayRef *lggoArray = dynamic_cast(*retval); [array enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) { lggoArray->addObject([self transmuteToGraphObject:obj]); diff --git a/Source/objc/LGGOMutableArray.mm b/Source/objc/LGGOMutableArray.mm index de4c12f..cf0c966 100644 --- a/Source/objc/LGGOMutableArray.mm +++ b/Source/objc/LGGOMutableArray.mm @@ -27,10 +27,12 @@ of this software and associated documentation files (the "Software"), to deal #import "LGGOMutableArray.h" @interface LGGOMutableArray () { - LGGOCXXSharedReference address; + LGGOCXXSharedReference reference; LGGOGraphContext *graphContext; } +@property (nonatomic, readonly) LGGOCXXSharedReference reference; + @end @implementation LGGOMutableArray @@ -40,16 +42,16 @@ - (id)initWithGraphObject:(const LGGOCXXSharedReference &)graphObject inContext: id retval; if (self) { - address = graphObject; + reference = graphObject; - id existingObject = (id)address->getNativeObject(); + id existingObject = (id)reference->getNativeObject(); if (existingObject) { [self release]; retval = [existingObject retain]; } else { graphContext = [context_ retain]; - address->setNativeObject(self); + reference->setNativeObject(self); } } @@ -60,17 +62,21 @@ - (id)initInContext:(LGGOGraphContext *)context_ { self = [super init]; if (self) { - address = LGGOCXXHackArrayRef::create(context_.CXXContext); + { + //LLVM/Clang 2.8 compiler bug work around + LGGOCXXSharedStoreContext context = context_.CXXContext; + reference = context->createArray(); + } graphContext = [context_ retain]; - address->setNativeObject(self); + reference->setNativeObject(self); } return self; } - (void)dealloc { - if (address.isValid()) { - address->setNativeObject(NULL); + if (reference.isValid()) { + reference->setNativeObject(NULL); } [graphContext release]; @@ -78,11 +84,11 @@ - (void)dealloc { } - (NSUInteger)count { - return dynamic_cast(*address)->getCount(); + return dynamic_cast(*reference)->getCount(); } - (id)objectAtIndex:(NSUInteger)index { - LGGOCXXSharedReference typedObject = dynamic_cast(*address)->getObjectAtIndex(index); + LGGOCXXSharedReference typedObject = dynamic_cast(*reference)->getObjectAtIndex(index); id retval = (id)typedObject->getNativeObject(); if (!retval) { @@ -95,27 +101,27 @@ - (id)objectAtIndex:(NSUInteger)index { - (void)addObject:(id)anObject { LGGOCXXSharedReference objectAddress = [graphContext transmuteToGraphObject:anObject]; - dynamic_cast(*address)->addObject(objectAddress); + dynamic_cast(*reference)->addObject(objectAddress); } - (void)insertObject:(id)anObject atIndex:(NSUInteger)index { LGGOCXXSharedReference objectAddress = [graphContext transmuteToGraphObject:anObject]; - dynamic_cast(*address)->insertObjectAtIndex(objectAddress, index); + dynamic_cast(*reference)->insertObjectAtIndex(objectAddress, index); } - (void)removeLastObject { - dynamic_cast(*address)->removeLastObject(); + dynamic_cast(*reference)->removeLastObject(); } - (void)removeObjectAtIndex:(NSUInteger)index { - dynamic_cast(*address)->removeObjectAtIndex(index); + dynamic_cast(*reference)->removeObjectAtIndex(index); } - (void)replaceObjectAtIndex:(NSUInteger)index withObject:(id)anObject { LGGOCXXSharedReference objectAddress = [graphContext transmuteToGraphObject:anObject]; - dynamic_cast(*address)->replaceObjectAtIndexWithObject(objectAddress, index); + dynamic_cast(*reference)->replaceObjectAtIndexWithObject(objectAddress, index); } @end diff --git a/Source/objc/LGGONumber.mm b/Source/objc/LGGONumber.mm index 1d82ef0..11c39a7 100644 --- a/Source/objc/LGGONumber.mm +++ b/Source/objc/LGGONumber.mm @@ -30,11 +30,11 @@ of this software and associated documentation files (the "Software"), to deal #import "LGGONumber.h" @interface LGGONumber () { - LGGOCXXSharedReference address; + LGGOCXXSharedReference reference; LGGOGraphContext *graphContext; } -@property LGGOCXXSharedReference address; +@property (nonatomic, readonly) LGGOCXXSharedReference reference; @end @implementation LGGONumber @@ -44,17 +44,17 @@ - (id)initWithGraphObject:(const LGGOCXXSharedReference &)graphObject inContext: id retval; if (self) { - address = graphObject; + reference = graphObject; - id existingObject = (id)address->getNativeObject(); + id existingObject = (id)reference->getNativeObject(); if (existingObject) { - address = LGGOCXXSharedReference(); + reference = LGGOCXXSharedReference(); [self release]; retval = [existingObject retain]; } else { graphContext = [context_ retain]; - address->setNativeObject(self); + reference->setNativeObject(self); } } @@ -67,19 +67,23 @@ - (id)initWithNumber:(NSNumber *)number_ inContext:(LGGOGraphContext *)context_ id retval; if (self) { - address = LGGOCXXNumberRef::create(context_.CXXContext, number_.longLongValue); + { + //LLVM/Clang 2.8 compiler bug work around + LGGOCXXSharedStoreContext context = context_.CXXContext; + reference = context->createNumber(number_.longLongValue); + } - id existingObject = (id)address->getNativeObject(); + id existingObject = (id)reference->getNativeObject(); if (existingObject) { //We do this here so that the when the ObjC runtime destructs the C++ ivar it has an empty object to chew on - address = LGGOCXXSharedReference(); + reference = LGGOCXXSharedReference(); [self release]; retval = [existingObject retain]; } else { retval = self; graphContext = [context_ retain]; - address->setNativeObject(self); + reference->setNativeObject(self); } } @@ -87,8 +91,8 @@ - (id)initWithNumber:(NSNumber *)number_ inContext:(LGGOGraphContext *)context_ } - (void) dealloc { - if (address.isValid()) { - address->setNativeObject(NULL); + if (reference.isValid()) { + reference->setNativeObject(NULL); } [graphContext release]; @@ -96,8 +100,8 @@ - (void) dealloc { } - (void)getValue:(void *)value_ { - LGGOCXXNumberRef *sharedNumber = dynamic_cast(*address); - switch(sharedNumber->getType()) { + LGGOCXXNumberRef *sharedNumber = dynamic_cast(*reference); + switch(sharedNumber->getNumberType()) { case kLGGOCXX8BitSignedNumberType: case kLGGOCXX16BitSignedNumberType: case kLGGOCXX32BitSignedNumberType: @@ -119,9 +123,9 @@ - (void)getValue:(void *)value_ { #define LGGO_NUMBER_ACCESSOR(datatype, name) \ - (datatype)name { \ - LGGOCXXNumberRef *sharedNumber = dynamic_cast(*address); \ + LGGOCXXNumberRef *sharedNumber = dynamic_cast(*reference); \ datatype retval; \ - switch(sharedNumber->getType()) { \ + switch(sharedNumber->getNumberType()) { \ case kLGGOCXX8BitSignedNumberType : \ case kLGGOCXX16BitSignedNumberType : \ case kLGGOCXX32BitSignedNumberType : \ @@ -155,7 +159,7 @@ - (datatype)name { - (const char *)objCType { const char *retval; - switch(dynamic_cast(*address)->getType()) { + switch(dynamic_cast(*reference)->getNumberType()) { case kLGGOCXX8BitSignedNumberType : retval = "c"; break; case kLGGOCXX8BitUnsignedNumberType : retval = "C"; break; case kLGGOCXX16BitSignedNumberType : retval = "i"; break; diff --git a/Source/objc/LGGOString.mm b/Source/objc/LGGOString.mm index 05368b1..21801a9 100644 --- a/Source/objc/LGGOString.mm +++ b/Source/objc/LGGOString.mm @@ -28,11 +28,11 @@ of this software and associated documentation files (the "Software"), to deal @interface LGGOString () { - LGGOCXXSharedReference address; + LGGOCXXSharedReference reference; LGGOGraphContext *graphContext; } -@property LGGOCXXSharedReference address; +@property (nonatomic, readonly) LGGOCXXSharedReference reference; @end @@ -43,16 +43,16 @@ - (id)initWithGraphObject:(const LGGOCXXSharedReference &)graphObject inContext: id retval; if (self) { - address = graphObject; + reference = graphObject; - id existingObject = (id)address->getNativeObject(); + id existingObject = (id)reference->getNativeObject(); if (existingObject) { [self release]; retval = [existingObject retain]; } else { graphContext = [context_ retain]; - address->setNativeObject(self); + reference->setNativeObject(self); } } @@ -64,18 +64,22 @@ - (id)initWithString:(NSString *)string_ inContext:(LGGOGraphContext *)context_ id retval; if (self) { - address = LGGOCXXStringRef::create(context_.CXXContext, string_.UTF8String); + { + //LLVM/Clang 2.8 compiler bug work around + LGGOCXXSharedStoreContext context = context_.CXXContext; + reference = context->createString(string_.UTF8String); + } - id existingObject = (id)address->getNativeObject(); + id existingObject = (id)reference->getNativeObject(); if (existingObject) { - address = LGGOCXXSharedReference(); + reference = LGGOCXXSharedReference(); [self release]; retval = [existingObject retain]; } else { retval = self; graphContext = [context_ retain]; - address->setNativeObject(self); + reference->setNativeObject(self); } } @@ -83,8 +87,8 @@ - (id)initWithString:(NSString *)string_ inContext:(LGGOGraphContext *)context_ } - (void) dealloc { - if (address.isValid()) { - address->setNativeObject(NULL); + if (reference.isValid()) { + reference->setNativeObject(NULL); } [graphContext release]; @@ -92,11 +96,11 @@ - (void) dealloc { } - (NSUInteger)length { - return dynamic_cast(*address)->getLength(); + return dynamic_cast(*reference)->getLength(); } - (unichar)characterAtIndex:(NSUInteger)index { - return dynamic_cast(*address)->getCharacterAtIndex(index); + return dynamic_cast(*reference)->getCharacterAtIndex(index); } #if 0 diff --git a/Tests/LGGOStringTests.m b/Tests/LGGOStringTests.m index 1f60132..c99cfa3 100644 --- a/Tests/LGGOStringTests.m +++ b/Tests/LGGOStringTests.m @@ -108,7 +108,6 @@ - (void) setUp { for (j = 0; j < i; j++) { LGGOString *testString = [[LGGOString alloc] initWithString:string inContext:context]; NSRange range = NSMakeRange(j, i-j); -// NSRange range = NSMakeRange(0, length); unichar *stringBuffer = alloca(sizeof(unichar)*length); unichar *testStringBuffer = alloca(sizeof(unichar)*length); @@ -120,10 +119,6 @@ - (void) setUp { testStringBuffer, sizeof(unichar)*(i-j)), nil); - - // free(stringBuffer); - // free(testStringBuffer); - // [testString release]; } }