diff --git a/GraphObjects.xcodeproj/project.pbxproj b/GraphObjects.xcodeproj/project.pbxproj index e51d295..7e7b3da 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,37 +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 */; }; + 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 */ @@ -68,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 = ""; }; @@ -78,25 +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 = ""; }; + 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 = ""; }; @@ -107,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 */ @@ -258,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 = ""; @@ -276,7 +280,6 @@ isa = PBXGroup; children = ( BFD68E4C1278C4DC004CBBD2 /* unicode */, - BF3355761276523900F34934 /* LGGOCXXAddress.h */, BF3355771276523900F34934 /* LGGOByteOrder.h */, ); path = Utilities; @@ -304,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; @@ -334,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; }; @@ -444,18 +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 */, + BFA37A241280DC59002A0892 /* LGGOCXXObjectRef.cpp in Sources */, + BF8B7F5C128DD72300B39D0A /* LGGOCXXReferenceMetadata.cpp in Sources */, ); runOnlyForDeploymentPostprocessing = 0; }; @@ -491,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; @@ -508,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/README.md b/README.md index 63efe65..da35259 100644 --- a/README.md +++ b/README.md @@ -6,10 +6,12 @@ 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__ 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) +* Github repo: [https://github.com/GLsoft/GraphObjects](https://github.com/GLsoft/GraphObjects) \ No newline at end of file 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..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 { @@ -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..aad6413 100644 --- a/Source/Storage/LGGOCXXStoreContext.cpp +++ b/Source/Storage/LGGOCXXStoreContext.cpp @@ -26,118 +26,122 @@ #include -#include "LGGOCXXType.h" +#include "LGGOCXXReference.h" #include "LGGOCXXStore.h" #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) - : store(S), nextAddressValue(256), nativeRetainFunc(NULL), nativeReleaseFunc(NULL) { - writableSegment = new LGGOCXXWritableStoreSegment; + : store(S), nextAddressValue(256) { } -LGGOCXXAddress LGGOCXXStoreContext::getNextFreeAddress (void) { - LGGOCXXAddress retval = LGGOCXXAddress(nextAddressValue<<4); +uint64_t LGGOCXXStoreContext::getNextFreeAddress (void) { + uint64_t retval = nextAddressValue<<4; nextAddressValue++; return retval; } -void LGGOCXXStoreContext::setNativeObjectRetain(void (*NRF)(void *)) { - nativeRetainFunc = NRF; +LGGOCXXSharedReference LGGOCXXStoreContext::createArray(void) { + return LGGOCXXSharedReference(shared_from_this(), new LGGOCXXHackArrayRef()); } -void LGGOCXXStoreContext::setNativeObjectRelease(void (*NRF)(void *)) { - nativeReleaseFunc = NRF; +LGGOCXXSharedReference LGGOCXXStoreContext::createString(std::string S) { + return LGGOCXXSharedReference (shared_from_this(), new LGGOCXXStringRef(S)); } -void LGGOCXXStoreContext::nativeObjectRetain(void *nativeObject) { - if (nativeRetainFunc) { - nativeRetainFunc(nativeObject); - } +LGGOCXXSharedReference LGGOCXXStoreContext::createNumber(int64_t N) { + return LGGOCXXSharedReference (shared_from_this(), new LGGOCXXNumberRef(N)); } -void LGGOCXXStoreContext::nativeObjectRelease(void *nativeObject) { - if (nativeReleaseFunc) { - nativeReleaseFunc(nativeObject); - } + +LGGOCXXSharedReference LGGOCXXStoreContext::createClass(std::string C) { + return LGGOCXXSharedReference (shared_from_this(), new LGGOCXXClassRef(C)); } + //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; +LGGOCXXReference * LGGOCXXStoreContext::rootObject(void) { + LGGOCXXSharedReference address(getReferenceForAddress(1<<4)); + return *address; } -LGGOCXXSharedType LGGOCXXStoreContext::resolvedObjectForAddress(LGGOCXXAddress address) { - LGGOCXXSharedType retval; - - std::map::iterator i; - i = resolvedObjects.find(address); +void LGGOCXXStoreContext::setRootObject(LGGOCXXReference *T) { + LGGOCXXSharedReference address(shared_from_this(), 1<<4); + address.setReference(T); +} - if (i != resolvedObjects.end()) { - retval = i->second; - } +LGGOCXXSharedReference LGGOCXXStoreContext::getReferenceForAddress (uint64_t address) { + std::map::iterator i = addresses.find(address); - return retval; -} + if (i == addresses.end()) { + return LGGOCXXSharedReference(i->second); + } else { + assert(0); + LGGOCXXSharedReference retval = LGGOCXXSharedReference(shared_from_this(), address); + setReferenceForAddress(LGGOCXXWeakReference(retval), address); + return retval; + } +}; -LGGOCXXSharedType LGGOCXXStoreContext::rootObject(void) { - return getObjectForAddress(LGGOCXXAddress(1<<4)); +void LGGOCXXStoreContext::setReferenceForAddress(const LGGOCXXWeakReference& reference, uint64_t address) { + addresses.insert(std::pair(address, reference)); } -void LGGOCXXStoreContext::setRootObject(const LGGOCXXSharedType &object) { - setResolvedObjectForAddress(object, LGGOCXXAddress(1<<4)); - setObjectForAddress(object, LGGOCXXAddress(1<<4)); -} +LGGOCXXSharedReference 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 LGGOCXXSharedReference(i->second); + } + + return LGGOCXXSharedReference(); } -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..d7ffd9d 100644 --- a/Source/Storage/LGGOCXXStoreContext.h +++ b/Source/Storage/LGGOCXXStoreContext.h @@ -34,44 +34,46 @@ typedef std::tr1::weak_ptr LGGOCXXWeakStoreContext; #define LGGOCXXSTORECONTEXT_H #include +#include +#include "LGGOCXXMemoryDescriptor.h" #include "LGGOCXXStore.h" #include "LGGOCXXStoreSegment.h" -#include "LGGOCXXType.h" -#include "LGGOCXXAddress.h" +#include "LGGOCXXReference.h" +#include "LGGOCXXReferenceMetadata.h" 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); + + LGGOCXXSharedReference createString(std::string S); + LGGOCXXSharedReference createNumber(int64_t N); + LGGOCXXSharedReference createArray(void); + LGGOCXXSharedReference createClass(std::string C); + + LGGOCXXReference * rootObject(void); + void setRootObject(LGGOCXXReference *T); - void setNativeObjectRetain(void (*NRF)(void *)); - void setNativeObjectRelease(void (*NRF)(void *)); - void nativeObjectRetain(void *nativeObject); - void nativeObjectRelease(void *nativeObject); + LGGOCXXSharedReference getReferenceForAddress (uint64_t address); + LGGOCXXSharedMemoryDescriptor getDescriptorForAddress (uint64_t address); + void setReferenceForAddress(const LGGOCXXWeakReference& reference, uint64_t address); + LGGOCXXSharedReference getAddressForAddressValue(uint64_t addressValue); }; #endif \ No newline at end of file diff --git a/Source/Storage/LGGOCXXStoreSegment.cpp b/Source/Storage/LGGOCXXStoreSegment.cpp index 6574372..6464ca3 100644 --- a/Source/Storage/LGGOCXXStoreSegment.cpp +++ b/Source/Storage/LGGOCXXStoreSegment.cpp @@ -47,19 +47,19 @@ LGGOCXXStoreSegment::LGGOCXXStoreSegment(LGGOCXXSharedMemoryDescriptor D) : desc pointerCount = LGGOSwapLittleToHost64(*((uint64_t *)&segmentData[16])); hashCount = LGGOSwapLittleToHost64(*((uint64_t *)&segmentData[24])); pointerPointerTableOffset = 4*sizeof(uint64_t); - pointerHashTableOffset = pointerPointerTableOffset + (pointerCount * sizeof(LGGOCXXAddress)); + pointerHashTableOffset = pointerPointerTableOffset + (pointerCount * HASHTABLE_RECORD_SIZE); hashHashTableOffset = pointerHashTableOffset + (pointerCount * CC_SHA224_DIGEST_LENGTH); hashDataTableOffset = hashHashTableOffset + (hashCount*HASHTABLE_RECORD_SIZE); } -void LGGOCXXStoreSegment::setDescriptorForAddress(const LGGOCXXSharedMemoryDescriptor &objectt, LGGOCXXAddress address) { +void LGGOCXXStoreSegment::setDescriptorForAddress(const LGGOCXXSharedMemoryDescriptor &objectt, uint64_t address) { //Make this something real someday throw; } -LGGOCXXSharedMemoryDescriptor LGGOCXXStoreSegment::getDescriptorForAddress (LGGOCXXAddress address) { +LGGOCXXSharedMemoryDescriptor LGGOCXXStoreSegment::getDescriptorForAddress (uint64_t address) { LGGOCXXSharedMemoryDescriptor retval = LGGOCXXSharedMemoryDescriptor((LGGOCXXMemoryDescriptor *)NULL); uint8_t *segmentData = (uint8_t *)descriptor->getData(); @@ -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,14 +100,14 @@ 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); + std::map::iterator i = memoryObjects.find(address); if (i != memoryObjects.end()) { retval = i->second; @@ -119,14 +119,14 @@ 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; 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..add959d 100644 --- a/Source/Storage/LGGOCXXStoreSegment.h +++ b/Source/Storage/LGGOCXXStoreSegment.h @@ -40,27 +40,29 @@ 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 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; + std::map memoryObjects; protected: 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 deleted file mode 100644 index 3265e62..0000000 --- a/Source/Types/Collections/HackArray/LGGOCXXHackArray.cpp +++ /dev/null @@ -1,86 +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(); -} - -LGGOCXXSharedType LGGOCXXHackArray::getObjectAtIndex(uint64_t i) { - LGGOCXXSharedType retval; - - 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; -} - -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 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::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 LGGOCXXSharedType& object, uint64_t index) { - std::vector::iterator i = objects.begin()+index; - objects[index] = object->getAddress(); -} - -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..502ce17 --- /dev/null +++ b/Source/Types/Collections/HackArray/LGGOCXXHackArrayRef.cpp @@ -0,0 +1,63 @@ +/* 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" + +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 69% rename from Source/Types/Collections/HackArray/LGGOCXXHackArray.h rename to Source/Types/Collections/HackArray/LGGOCXXHackArrayRef.h index b023a6e..bb93398 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,25 +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: - LGGOCXXAddress address; - std::vector objects; - bool dirty:1; -public: - LGGOCXXHackArray(LGGOCXXSharedStoreContext C) : LGGOCXXType(C), address(0), dirty(true) { } + std::vector objects; + LGGOCXXHackArrayRef(void) : LGGOCXXReference() { } +public: uint64_t getCount(void); - LGGOCXXSharedType getObjectAtIndex(uint64_t i); + LGGOCXXSharedReference getObjectAtIndex(uint64_t i); - void addObject(const LGGOCXXSharedType& object); - void insertObjectAtIndex(const LGGOCXXSharedType& 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 LGGOCXXSharedType& object, uint64_t index); + void replaceObjectAtIndexWithObject(const LGGOCXXSharedReference& 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); + + friend LGGOCXXSharedReference LGGOCXXStoreContext::createArray(void); }; \ No newline at end of file diff --git a/Source/Types/LGGOCXXClass.cpp b/Source/Types/LGGOCXXClassRef.cpp similarity index 71% rename from Source/Types/LGGOCXXClass.cpp rename to Source/Types/LGGOCXXClassRef.cpp index 8c181ed..8e93361 100644 --- a/Source/Types/LGGOCXXClass.cpp +++ b/Source/Types/LGGOCXXClassRef.cpp @@ -21,34 +21,23 @@ */ -#include "LGGOCXXClass.h" +#include "LGGOCXXClassRef.h" -LGGOCXXClass::LGGOCXXClass(LGGOCXXSharedStoreContext C, std::string N) : LGGOCXXType(C), name(N), dirty(true) { +LGGOCXXClassRef::LGGOCXXClassRef(std::string N) : LGGOCXXReference(), name(N) { } -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) { +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]; } @@ -74,14 +63,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 = sizeof(LGGOCXXAddress)*relations.size(); + uint32_t retval = LGGOCXXReferenceMetadata_SERIALIZED_SIZE*relations.size(); std::map::iterator i; @@ -101,17 +90,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; @@ -129,15 +118,10 @@ uint32_t LGGOCXXClass::getRelationOffset(std::string name) { return retval; } - -LGGOCXXSharedMemoryDescriptor LGGOCXXClass::getSerializedData (void) { - return NULL_DESCRIPTOR; -} - -bool LGGOCXXClass::isDusty (void) { - return false; +uint64_t LGGOCXXClassRef::getTagValue (void) { + return 0; } -bool LGGOCXXClass::isDirty (void) { - return dirty; +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 86% rename from Source/Types/LGGOCXXClass.h rename to Source/Types/LGGOCXXClassRef.h index 9e800be..6dd29ef 100644 --- a/Source/Types/LGGOCXXClass.h +++ b/Source/Types/LGGOCXXClassRef.h @@ -21,28 +21,28 @@ */ -#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: - LGGOCXXAddress address; std::string name; std::map properties; std::map relations; bool dirty:1; -public: - LGGOCXXClass(LGGOCXXSharedStoreContext C, std::string N); + + explicit LGGOCXXClassRef(std::string N); +public: void addProperty(std::string name, LGGOCXXScalarEncodingType type); void addRelation(std::string name, LGGOCXXRelationEncodingType type, LGGOCXXRelationSemanticsType semantics); @@ -52,12 +52,11 @@ 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 bool isDirty(void); - virtual bool isDusty(void); + 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/LGGOCXXNumber.cpp b/Source/Types/LGGOCXXNumberRef.cpp similarity index 59% rename from Source/Types/LGGOCXXNumber.cpp rename to Source/Types/LGGOCXXNumberRef.cpp index 3098b43..1145d13 100644 --- a/Source/Types/LGGOCXXNumber.cpp +++ b/Source/Types/LGGOCXXNumberRef.cpp @@ -20,18 +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(LGGOCXXSharedStoreContext C, int64_t N) : LGGOCXXType(C), dirty(true), address(0) { +LGGOCXXNumberRef::LGGOCXXNumberRef(int64_t N) : LGGOCXXReference(), 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) { @@ -68,54 +62,46 @@ LGGOCXXNumber::LGGOCXXNumber(LGGOCXXSharedStoreContext C, int64_t N) : LGGOCXXTy } } -LGGOCXXScalarEncodingType LGGOCXXNumber::getType(void) { +LGGOCXXScalarEncodingType LGGOCXXNumberRef::getNumberType(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 LGGOCXXNumberRef::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) { +LGGOCXXSharedMemoryDescriptor LGGOCXXNumberRef::getSerializedData(void) { return NULL_DESCRIPTOR; } -bool LGGOCXXNumber::isDirty(void) { - return dirty; -} - -bool LGGOCXXNumber::isDusty(void) { - return false; -} - -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; +int64_t LGGOCXXNumberRef::signedValue (void) { + return *((int64_t *)&rawValue); } -uint64_t LGGOCXXNumber::unsignedValue (void) { - return (address.getAddressValue() >> 5); +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 81% rename from Source/Types/LGGOCXXNumber.h rename to Source/Types/LGGOCXXNumberRef.h index c4f1fee..6d60c50 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,27 +38,28 @@ typedef enum { LGGOCXXIntegerTypeEncoding = 0, LGGOCXXUnsignedFloatTypEncodinge = 1 -} LGGOCXXNumberEncodingType; +} LGGOCXXNumberRefEncodingType; -class LGGOCXXNumber : public LGGOCXXType { +class LGGOCXXNumberRef : public LGGOCXXReference { private: + uint64_t rawValue; LGGOCXXSharedMemoryDescriptor descriptor; - LGGOCXXAddress address; LGGOCXXScalarEncodingType type; bool dirty:1; + + explicit LGGOCXXNumberRef(int64_t N); public: - explicit LGGOCXXNumber(LGGOCXXSharedStoreContext C, int64_t N); - LGGOCXXScalarEncodingType getType(void); + LGGOCXXScalarEncodingType getNumberType(void); int64_t signedValue (void); uint64_t unsignedValue (void); 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); + + friend LGGOCXXSharedReference LGGOCXXStoreContext::createNumber(int64_t N); }; #endif \ No newline at end of file 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 71% rename from Source/Types/LGGOCXXType.cpp rename to Source/Types/LGGOCXXReference.cpp index b1f7524..dff3ec4 100644 --- a/Source/Types/LGGOCXXType.cpp +++ b/Source/Types/LGGOCXXReference.cpp @@ -20,26 +20,28 @@ */ -#include "LGGOCXXType.h" +#include "LGGOCXXReference.h" -LGGOCXXType::LGGOCXXType(const LGGOCXXSharedStoreContext &C) : context(C), clientData(NULL) { +LGGOCXXReference::LGGOCXXReference(void) : clientData(NULL) { + +} +LGGOCXXWeakReference LGGOCXXReference::getMetadata(void) { + return metadata; } -LGGOCXXSharedStoreContext LGGOCXXType::getContext(void) { - return context; +void LGGOCXXReference::setMetadata (const LGGOCXXWeakReference &R) { + metadata = R; } -void *LGGOCXXType::getNativeObject(void) { +void *LGGOCXXReference::getNativeObject(void) { return clientData; } -void LGGOCXXType::setNativeObject(void *D) { - if (D) { - getContext()->nativeObjectRetain(D); - } - if (clientData) { - getContext()->nativeObjectRelease(clientData); - } +const LGGOCXXSharedStoreContext &LGGOCXXReference::getContext(void) { + return metadata.getContext(); +} + +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 73% rename from Source/Types/LGGOCXXType.h rename to Source/Types/LGGOCXXReference.h index ff8d967..c1847c7 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,32 +53,34 @@ 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; -virtual class LGGOCXXType : public std::tr1::enable_shared_from_this { +class LGGOCXXReference { private: - LGGOCXXSharedStoreContext context; + LGGOCXXWeakReference metadata; void *clientData; public: - LGGOCXXType(const LGGOCXXSharedStoreContext& C); - LGGOCXXSharedStoreContext getContext(void); + explicit LGGOCXXReference(void); + LGGOCXXWeakReference getMetadata(void); + void setMetadata (const LGGOCXXWeakReference &R); + + const LGGOCXXSharedStoreContext& getContext(void); + void *getNativeObject(void); void setNativeObject(void *D); - virtual LGGOCXXAddress getAddress(void) = 0; virtual LGGOCXXSharedMemoryDescriptor getSerializedData (void) = 0; - virtual bool isDirty(void) = 0; - virtual bool isDusty(void) = 0; + virtual uint64_t getTagValue (void) = 0; }; #endif \ No newline at end of file diff --git a/Source/Types/LGGOCXXReferenceMetadata.cpp b/Source/Types/LGGOCXXReferenceMetadata.cpp new file mode 100644 index 0000000..32346f8 --- /dev/null +++ b/Source/Types/LGGOCXXReferenceMetadata.cpp @@ -0,0 +1,373 @@ +/* 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 "LGGOCXXReferenceMetadata.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 + +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); + R->setMetadata(weakAddr); + address = C->getNextFreeAddress(); + C->setReferenceForAddress(LGGOCXXWeakReference(this), address); + LG_LOG("Create 0x%llx real address\n", getAddressValue()); + assert(reference->getMetadata().getAddressValue() == address); +} + +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); + R->setMetadata(weakAddr); + C->setReferenceForAddress(LGGOCXXWeakReference(this), address); + LG_LOG("Create 0x%llx real address\n", getAddressValue()); + assert(reference->getMetadata().getAddressValue() == address); + assert(reference->getMetadata().getAddressValue() == A); +} + +const uint64_t LGGOCXXReferenceMetadata::getAddressValue (void) { + return address; +} + +const LGGOSimpleType LGGOCXXReferenceMetadata::getType (void) const { + return static_cast(address | (uint64_t)0x00ff); +} + +const bool LGGOCXXReferenceMetadata::isNative (void) const { + return ((address | (uint64_t)0x00ff) == kLGGOAddressNativeType); +} + +const bool LGGOCXXReferenceMetadata::isValid (void) const { + return address != 0; +} + + +uint64_t LGGOCXXReferenceMetadata::getConcreteAddressValue (void) const { + return address; +} + +void LGGOCXXReferenceMetadata::incrementStrongCount (void) { + LG_LOG("Counts:%u/%u 0x%lx\n", strongRefCount, weakRefCount, (uintptr_t)this); + LG_BACKTRACE(); + strongRefCount++; +} + +void LGGOCXXReferenceMetadata::decrementStrongCount (void) { + LG_LOG("Counts:%u/%u 0x%lx\n", strongRefCount, weakRefCount, (uintptr_t)this); + LG_BACKTRACE(); + assert(strongRefCount > 0); + strongRefCount--; + + if (strongRefCount == 0) { + delete reference; + + if (weakRefCount == 0) { +// delete this; + } + } +} + +void LGGOCXXReferenceMetadata::incrementWeakCount (void) { + LG_LOG("Counts:%u/%u 0x%lx\n", strongRefCount, weakRefCount, (uintptr_t)this); + LG_BACKTRACE(); + weakRefCount++; +} + +void LGGOCXXReferenceMetadata::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 LGGOCXXReferenceMetadata::operator== (const LGGOCXXReferenceMetadata& R) { + return (address == R.address); +} + +bool LGGOCXXReferenceMetadata::operator> (const LGGOCXXReferenceMetadata& b) const { + return address > b.address; +} + +bool LGGOCXXReferenceMetadata::operator< (const LGGOCXXReferenceMetadata& b) const { + return address < b.address; +} + +LGGOCXXSharedStoreContext LGGOCXXReferenceMetadata::getContext(void) { + if (context.expired()) { + return LGGOCXXSharedStoreContext(); + } else { + return LGGOCXXSharedStoreContext(context); + + } +} + +LGGOCXXReference * LGGOCXXReferenceMetadata::getReference (void) { + return reference; +} + +void LGGOCXXReferenceMetadata::setReference (LGGOCXXReference *R) { + reference = R; +} + +bool LGGOCXXReferenceMetadata::getDirty (void) { + return dirty; +} + +void LGGOCXXReferenceMetadata::setDirty (bool D) { + dirty = D; +} + +bool LGGOCXXReferenceMetadata::getDusty (void) { + return dusty; +} + +void LGGOCXXReferenceMetadata::setDusty (bool D) { + dusty = D; +} + +bool LGGOCXXSharedReference::getDirty (void) { + return metadata->getDirty(); +} + +void LGGOCXXSharedReference::setDirty (bool D) { + metadata->setDirty(D); +} + +bool LGGOCXXSharedReference::getDusty (void) { + return metadata->getDusty(); +} + +void LGGOCXXSharedReference::setDusty (bool D) { + metadata->setDusty(D); +} + +#pragma mark - +#pragma mark Strong Pointer Implementation + +LGGOCXXSharedReference::LGGOCXXSharedReference(void) : metadata(NULL) { + //printf("Create NULL strong address\n"); +} + +LGGOCXXSharedReference::LGGOCXXSharedReference(const LGGOCXXWeakReference& R) : metadata(R.metadata) { + if (metadata) { + metadata->incrementStrongCount(); + } +} + +LGGOCXXSharedReference::LGGOCXXSharedReference(const LGGOCXXSharedReference& R) : metadata(R.metadata) { + if (metadata) { + metadata->incrementStrongCount(); + } +} + +LGGOCXXSharedReference::LGGOCXXSharedReference(const LGGOCXXSharedStoreContext& C, uint64_t A) { + assert(A != 0); + LGGOCXXSharedReference existingAddress = C->getAddressForAddressValue(A); + if (existingAddress.isValid()) { + metadata = existingAddress.metadata; + metadata->incrementStrongCount(); + } else { + assert(0); + } + assert(metadata->getAddressValue() == A); + //printf("Create 0x%llx strong address\n", address->getAddressValue()); +} + +LGGOCXXSharedReference::LGGOCXXSharedReference(const LGGOCXXSharedStoreContext& C, LGGOCXXReference *T) { + uint64_t tagValue = T->getTagValue(); + + if (tagValue) { + LGGOCXXSharedReference existingAddress = C->getAddressForAddressValue(tagValue); + if (existingAddress.isValid()) { + metadata = existingAddress.metadata; + } else { + metadata = new LGGOCXXReferenceMetadata(C, T, tagValue); + } + assert(metadata->getAddressValue() == tagValue); + //printf("Create 0x%llx strong address\n", address->getAddressValue()); + } else { + metadata = new LGGOCXXReferenceMetadata(C, T); + } + metadata->incrementStrongCount(); + //printf("Create 0x%llx strong address\n", address->getAddressValue()); +} + + +LGGOCXXSharedReference::~LGGOCXXSharedReference(void) { + if (metadata) { + metadata->decrementStrongCount(); + } +} + +LGGOCXXSharedStoreContext LGGOCXXSharedReference::getContext(void) { + assert(metadata != NULL); + return metadata->getContext(); +} + +uint64_t LGGOCXXSharedReference::getAddressValue(void) { + return metadata->getAddressValue(); +} + +LGGOCXXReference *LGGOCXXSharedReference::getReference (void) { + assert(metadata != NULL); + return metadata->getReference(); +} + +void LGGOCXXSharedReference::setReference (LGGOCXXReference *R) { + assert(metadata != NULL); + metadata->setReference(R); +} + +bool LGGOCXXSharedReference::isValid (void) { + return (metadata != NULL); +} + +LGGOCXXReference *LGGOCXXSharedReference::operator* (void) const { + assert(metadata != NULL); + return metadata->getReference(); +} + +LGGOCXXReference *LGGOCXXSharedReference::operator-> (void) const { + assert(metadata != NULL); + return metadata->getReference(); +} + +LGGOCXXSharedReference& LGGOCXXSharedReference::operator= (const LGGOCXXSharedReference& R) { + if (metadata) { + metadata->decrementStrongCount(); + } + metadata = R.metadata; + if (metadata) { + metadata->incrementStrongCount(); + } + return *this; +} + +#pragma mark - +#pragma mark Weak Pointer Implementation + +LGGOCXXWeakReference::LGGOCXXWeakReference(void) : metadata(NULL) { +// printf("Create NULL weak address\n"); +} + +LGGOCXXWeakReference::LGGOCXXWeakReference(LGGOCXXReferenceMetadata *MD) : metadata(MD) { +// printf("Create 0x%llx weak address\n", A->getAddressValue()); + if (metadata) { + metadata->incrementWeakCount(); + } +} + + +LGGOCXXWeakReference::LGGOCXXWeakReference(const LGGOCXXWeakReference& MD) : metadata(MD.metadata) { + if (metadata) { + metadata->incrementWeakCount(); + } +} + +LGGOCXXWeakReference::LGGOCXXWeakReference(const LGGOCXXSharedReference& MD) : metadata(MD.metadata) { + if (metadata) { + metadata->incrementWeakCount(); + } +} + +LGGOCXXWeakReference::~LGGOCXXWeakReference(void) { + if (metadata) { + metadata->decrementWeakCount(); + } +} + +LGGOCXXSharedStoreContext LGGOCXXWeakReference::getContext(void) { + assert(metadata != NULL); + return metadata->getContext(); +} + +uint64_t LGGOCXXWeakReference::getAddressValue(void) { + return metadata->getAddressValue(); +} + +bool LGGOCXXWeakReference::isValid (void) { + return (metadata != NULL); +} + +LGGOCXXWeakReference& LGGOCXXWeakReference::operator= (const LGGOCXXWeakReference& R) { + if (metadata) { + metadata->decrementWeakCount(); + } + metadata = R.metadata; + if (metadata) { + metadata->incrementWeakCount(); + } + return *this; +} + +bool LGGOCXXWeakReference::getDirty (void) { + return metadata->getDirty(); +} + +void LGGOCXXWeakReference::setDirty (bool D) { + metadata->setDirty(D); +} + +bool LGGOCXXWeakReference::getDusty (void) { + return metadata->getDusty(); +} + +void LGGOCXXWeakReference::setDusty (bool D) { + metadata->setDusty(D); +} diff --git a/Source/Types/LGGOCXXReferenceMetadata.h b/Source/Types/LGGOCXXReferenceMetadata.h new file mode 100644 index 0000000..1699ff6 --- /dev/null +++ b/Source/Types/LGGOCXXReferenceMetadata.h @@ -0,0 +1,156 @@ +/* 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. + + */ + +class LGGOCXXSharedReference; +class LGGOCXXWeakReference; + +#include "LGGOCXXReference.h" +#include "LGGOCXXStoreContext.h" + +#ifndef LGGOREFERENCEMETADATA_H +#define LGGOREFERENCEMETADATA_H + +#define LGGOCXXReferenceMetadata_SERIALIZED_SIZE (8) + +typedef enum { + kLGGOAddressNativeType = 0, + kLGGOAddressConstantType = 1, + kLGGOAddressNumberType = 3, + kLGGOAddressStringType = 4, + kLGGOAddressDateType = 5, + kLGGOAddressArrayType = 6, + kLGGOAddressComplexType = 15, + kLGGOAddressMutableArray = (kLGGOAddressComplexType | 1<<4), + kLGGOAddressMutableSet = (kLGGOAddressComplexType | 2<<4), + kLGGOAddressMutableDictionary = (kLGGOAddressComplexType | 3<<4) +} LGGOSimpleType; + +#include + +//FIXME we can be stupid clever here and half the size by using a union, but it is tricky + +class LGGOCXXReferenceMetadata { +private: + uint64_t address; + LGGOCXXWeakStoreContext context; + LGGOCXXReference *reference; + uint32_t strongRefCount; + uint32_t weakRefCount; + bool dirty:1; + bool dusty:1; + +public: + 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; + const bool isNative (void) const; + const bool isValid (void) const; + + uint64_t getConcreteAddressValue (void) const; + + void incrementStrongCount (void); + void decrementStrongCount (void); + + void incrementWeakCount (void); + void decrementWeakCount (void); + + LGGOCXXSharedStoreContext getContext(void); + + bool operator== (const LGGOCXXReferenceMetadata& A); + bool operator> (const LGGOCXXReferenceMetadata& b) const; + bool operator< (const LGGOCXXReferenceMetadata& b) const; + + LGGOCXXReference * getReference (void); + void setReference (LGGOCXXReference *R); + + bool getDirty (void); + void setDirty (bool D); + bool getDusty (void); + void setDusty (bool D); + + friend class LGGOCXXSharedReference; + friend class LGGOCXXWeakReference; +}; + +class LGGOCXXSharedReference { +private: + LGGOCXXReferenceMetadata *metadata; +public: + 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); + bool getDusty (void); + void setDusty (bool D); + + + LGGOCXXSharedStoreContext getContext(void); + uint64_t getAddressValue(void); + + LGGOCXXReference * getReference (void); + + void setReference (LGGOCXXReference *T); + bool isValid (void); + + LGGOCXXReference * operator* (void) const; + LGGOCXXReference * operator-> (void) const; + + LGGOCXXSharedReference& operator= (const LGGOCXXSharedReference& A); + + friend class LGGOCXXWeakReference; +}; + +class LGGOCXXWeakReference { +private: + LGGOCXXReferenceMetadata *metadata; +public: + LGGOCXXWeakReference(void); + explicit LGGOCXXWeakReference(const LGGOCXXSharedReference& A); + explicit LGGOCXXWeakReference(LGGOCXXReferenceMetadata *A); + LGGOCXXWeakReference(const LGGOCXXWeakReference&A); + ~LGGOCXXWeakReference(void); + + bool getDirty (void); + void setDirty (bool D); + bool getDusty (void); + void setDusty (bool D); + + LGGOCXXSharedStoreContext getContext(void); + uint64_t getAddressValue(void); + bool isValid (void); + + LGGOCXXWeakReference& operator= (const LGGOCXXWeakReference& A); + + friend class LGGOCXXSharedReference; +}; + + + + +#endif \ No newline at end of file diff --git a/Source/Types/LGGOCXXString.cpp b/Source/Types/LGGOCXXStringRef.cpp similarity index 77% rename from Source/Types/LGGOCXXString.cpp rename to Source/Types/LGGOCXXStringRef.cpp index 71c6731..f0cce83 100644 --- a/Source/Types/LGGOCXXString.cpp +++ b/Source/Types/LGGOCXXStringRef.cpp @@ -21,26 +21,27 @@ */ -#include "LGGOCXXString.h" +#include "LGGOCXXStringRef.h" #include #include "utf8.h" - -LGGOCXXString::LGGOCXXString(LGGOCXXSharedStoreContext C, std::string S) - : LGGOCXXType(C), charLength(0), lengthCalculated(false), dirty(true), address(0) { + +LGGOCXXStringRef::LGGOCXXStringRef(std::string S) + : LGGOCXXReference(), charLength(0), lengthCalculated(false) { 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,15 +52,17 @@ LGGOCXXString::LGGOCXXString(LGGOCXXSharedStoreContext C, std::string S) } } -bool LGGOCXXString::isDirty(void) { - return dirty; -} - -bool LGGOCXXString::isDusty(void) { - return false; +uint64_t LGGOCXXStringRef::getTagValue (void) { + uint64_t retval = 0; + + if (byteLength <= 7) { + retval = *((uint64_t *)stringDescriptor->getData()); + } + + return retval; } -uint32_t LGGOCXXString::getLength(void) { +uint32_t LGGOCXXStringRef::getLength(void) { if (lengthCalculated == false) { LGGOCXXCoreMemoryDescriptor::iterator i = stringDescriptor->begin()+1; @@ -77,7 +80,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; @@ -109,18 +112,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) { +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 86% rename from Source/Types/LGGOCXXString.h rename to Source/Types/LGGOCXXStringRef.h index 5ea6859..120954c 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,28 +36,28 @@ #include -#include "LGGOCXXType.h" +#include "LGGOCXXReference.h" -class LGGOCXXString : public LGGOCXXType { +class LGGOCXXStringRef : public LGGOCXXReference { private: LGGOCXXSharedMemoryDescriptor stringDescriptor; - LGGOCXXAddress address; uint32_t charLength; uint32_t byteLength; uint8_t offset; bool lengthCalculated:1; bool dirty:1; + + explicit LGGOCXXStringRef(std::string S); public: - explicit LGGOCXXString(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); - virtual LGGOCXXAddress getAddress(void); + virtual uint64_t getTagValue (void); virtual LGGOCXXSharedMemoryDescriptor getSerializedData (void); - virtual bool isDirty(void); - virtual bool isDusty(void); + friend LGGOCXXSharedReference LGGOCXXStoreContext::createString(std::string S); }; #endif \ No newline at end of file diff --git a/Source/Utilities/LGGOCXXAddress.h b/Source/Utilities/LGGOCXXAddress.h deleted file mode 100644 index 91dc4e1..0000000 --- a/Source/Utilities/LGGOCXXAddress.h +++ /dev/null @@ -1,73 +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. - - */ - -// FIXME -// In order to avoid lookups and solve cycles this will need to become our core custom smart pointer class - -#include "LGGOCXXType.h" - -#ifndef LGGOADDRESS_H -#define LGGOADDRESS_H - -typedef enum { - kLGGOAddressNativeType = 0, - kLGGOAddressConstantType = 1, - kLGGOAddressNumberType = 3, - kLGGOAddressStringType = 4, - kLGGOAddressDateType = 5, - kLGGOAddressArrayType = 6, - kLGGOAddressComplexType = 15 -} LGGOSimpleType; - -#include - -//FIXME we can be stupid clever here and half the size by using a union, but it is tricky - -class LGGOCXXAddress { -private: - uint64_t address; -public: - LGGOCXXAddress(const LGGOCXXAddress& A) : address(A.address) { } - explicit LGGOCXXAddress(uint64_t A = 0) : address(A) {} - const uint64_t getAddressValue (void) { return address; } - - 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; } - - - uint64_t getConcreteAddressValue (void) const { return address; } - - bool operator== (const LGGOCXXAddress& A) { - return (address == A.address); - } - - bool operator> (const LGGOCXXAddress& b) const { - return address > b.address; - } - - bool operator< (const LGGOCXXAddress& b) const { - return address < b.address; - } -}; - -#endif \ No newline at end of file diff --git a/Source/objc/LGGOClass.h b/Source/objc/LGGOClass.h index f9c7631..9b116cc 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 LGGOCXXSharedReference &)graphObject inContext:(LGGOGraphContext *)context_; @end diff --git a/Source/objc/LGGOClass.mm b/Source/objc/LGGOClass.mm index d082107..c347c6f 100644 --- a/Source/objc/LGGOClass.mm +++ b/Source/objc/LGGOClass.mm @@ -20,47 +20,55 @@ 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 () { - LGGOCXXSharedType sharedType; + LGGOCXXSharedReference reference; LGGOGraphContext *graphContext; } +@property (nonatomic, readonly) LGGOCXXSharedReference reference; + @end @implementation LGGOClass -- (id) initWithName:(NSString *)name_ inContext:(LGGOGraphContext *)context_ { +- (id)initWithGraphObject:(const LGGOCXXSharedReference &)graphObject inContext:(LGGOGraphContext *)context_ { self = [super init]; - + if (self) { - sharedType = LGGOCXXSharedType(new LGGOCXXClass(context_.CXXContext, std::string(name_.UTF8String))); + reference = graphObject; graphContext = [context_ retain]; - sharedType->setNativeObject(self); + reference->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; + { + //LLVM/Clang 2.8 compiler bug work around + LGGOCXXSharedStoreContext context = context_.CXXContext; + reference = context->createClass(name_.UTF8String); + } + graphContext = [context_ retain]; - sharedType->setNativeObject(self); + reference->setNativeObject(self); } - - return self; + + return self; } - (void) dealloc { + 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.h b/Source/objc/LGGOGraphContext.h index 6153a3c..f67bd66 100644 --- a/Source/objc/LGGOGraphContext.h +++ b/Source/objc/LGGOGraphContext.h @@ -26,7 +26,8 @@ #if defined __cplusplus #include "LGGOCXXStoreContext.h" -#include "LGGOCXXType.h" +#include "LGGOCXXReference.h" +#include "LGGOCXXReferenceMetadata.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:(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 e4f72a1..6db74c9 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 LGGOCXXSharedType +@protocol LGGOCXXSharedReference -@property (nonatomic, readonly) LGGOCXXSharedType sharedType; +@property (nonatomic, readonly) LGGOCXXSharedReference address; @end @@ -44,10 +44,10 @@ @interface LGGOGraphContext () { @implementation LGGOGraphContext - (id)initWithCXXContext:(const LGGOCXXSharedStoreContext&)context_ { - if ((self = [super init])) { + self = [super init]; + + if (self) { CXXContext = context_; - CXXContext->setNativeObjectRetain((void (*)(void *))&CFRetain); - CXXContext->setNativeObjectRelease((void (*)(void *))&CFRelease); } return self; @@ -65,51 +65,53 @@ - (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:(LGGOCXXSharedReference)address { + id retval = (id)(*address)->getNativeObject(); if (!retval) { - std::tr1::shared_ptr lggoArray = std::tr1::dynamic_pointer_cast(graphObject); - if (lggoArray.get()) { - return [[[LGGOMutableArray alloc] initWithGraphObject:graphObject inContext:self] autorelease]; + LGGOCXXHackArrayRef *lggoArray = dynamic_cast(*address); + if (lggoArray) { + return [[[LGGOMutableArray alloc] initWithGraphObject:address inContext:self] autorelease]; } - std::tr1::shared_ptr lggoString = std::tr1::dynamic_pointer_cast(graphObject); - if (lggoString.get()) { - return [[[LGGOString alloc] initWithGraphObject:graphObject inContext:self] autorelease]; + LGGOCXXStringRef *lggoString = dynamic_cast(*address); + if (lggoString) { + return [[[LGGOString alloc] initWithGraphObject:address inContext:self] autorelease]; } - std::tr1::shared_ptr lggoNumber = std::tr1::dynamic_pointer_cast(graphObject); - if (lggoNumber.get()) { - return [[[LGGONumber alloc] initWithGraphObject:graphObject inContext:self] autorelease]; + LGGOCXXNumberRef *lggoNumber = dynamic_cast(*address); + if (lggoNumber) { + return [[[LGGONumber alloc] initWithGraphObject:address inContext:self] autorelease]; } - - } return retval; } -- (LGGOCXXSharedType) transmuteToGraphObject:(id)object { - LGGOCXXSharedType retval; +- (LGGOCXXSharedReference) transmuteToGraphObject:(id)object { + LGGOCXXSharedReference 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 = self.CXXContext->createString(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)); + retval = self.CXXContext->createNumber(number.longLongValue); + 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 = self.CXXContext->createArray(); + LGGOCXXHackArrayRef *lggoArray = dynamic_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..ab99946 100644 --- a/Source/objc/LGGOMutableArray.h +++ b/Source/objc/LGGOMutableArray.h @@ -22,13 +22,14 @@ #import #if defined __cplusplus -#include "LGGOCXXType.h" +#include "LGGOCXXReferenceMetadata.h" +#include "LGGOCXXReference.h" #endif @interface LGGOMutableArray : NSMutableArray - (id)initInContext:(LGGOGraphContext *)context_; #if defined __cplusplus -- (id)initWithGraphObject:(const LGGOCXXSharedType &)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 9eb70ff..cf0c966 100644 --- a/Source/objc/LGGOMutableArray.mm +++ b/Source/objc/LGGOMutableArray.mm @@ -20,56 +20,75 @@ 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 () { - LGGOCXXSharedType sharedType; + LGGOCXXSharedReference reference; LGGOGraphContext *graphContext; } +@property (nonatomic, readonly) LGGOCXXSharedReference reference; + @end @implementation LGGOMutableArray -- (id)initWithGraphObject:(const LGGOCXXSharedType &)graphObject inContext:(LGGOGraphContext *)context_ { - self = [super init]; +- (id)initWithGraphObject:(const LGGOCXXSharedReference &)graphObject inContext:(LGGOGraphContext *)context_ { + self = [super init]; + id retval; if (self) { - sharedType = graphObject; - graphContext = [context_ retain]; - sharedType->setNativeObject(self); + reference = graphObject; + + id existingObject = (id)reference->getNativeObject(); + + if (existingObject) { + [self release]; + retval = [existingObject retain]; + } else { + graphContext = [context_ retain]; + reference->setNativeObject(self); + } } - return self; + return retval; } - (id)initInContext:(LGGOGraphContext *)context_ { self = [super init]; - if (self) { - sharedType = LGGOCXXSharedType(new LGGOCXXHackArray(context_.CXXContext)); + if (self) { + { + //LLVM/Clang 2.8 compiler bug work around + LGGOCXXSharedStoreContext context = context_.CXXContext; + reference = context->createArray(); + } graphContext = [context_ retain]; - sharedType->setNativeObject(self); + reference->setNativeObject(self); } return self; } - (void)dealloc { + if (reference.isValid()) { + reference->setNativeObject(NULL); + } [graphContext release]; [super dealloc]; } - (NSUInteger)count { - return std::tr1::dynamic_pointer_cast(sharedType)->getCount(); + return dynamic_cast(*reference)->getCount(); } + - (id)objectAtIndex:(NSUInteger)index { - LGGOCXXSharedType typedObject = std::tr1::dynamic_pointer_cast(sharedType)->getObjectAtIndex(index); + LGGOCXXSharedReference typedObject = dynamic_cast(*reference)->getObjectAtIndex(index); id retval = (id)typedObject->getNativeObject(); if (!retval) { @@ -80,29 +99,29 @@ - (id)objectAtIndex:(NSUInteger)index { } - (void)addObject:(id)anObject { - LGGOCXXSharedType object = [graphContext transmuteToGraphObject:anObject]; + LGGOCXXSharedReference objectAddress = [graphContext transmuteToGraphObject:anObject]; - std::tr1::dynamic_pointer_cast(sharedType)->addObject(object); + dynamic_cast(*reference)->addObject(objectAddress); } - (void)insertObject:(id)anObject atIndex:(NSUInteger)index { - LGGOCXXSharedType object = [graphContext transmuteToGraphObject:anObject]; + LGGOCXXSharedReference objectAddress = [graphContext transmuteToGraphObject:anObject]; - std::tr1::dynamic_pointer_cast(sharedType)->insertObjectAtIndex(object, index); + dynamic_cast(*reference)->insertObjectAtIndex(objectAddress, index); } - (void)removeLastObject { - std::tr1::dynamic_pointer_cast(sharedType)->removeLastObject(); + dynamic_cast(*reference)->removeLastObject(); } - (void)removeObjectAtIndex:(NSUInteger)index { - std::tr1::dynamic_pointer_cast(sharedType)->removeObjectAtIndex(index); + dynamic_cast(*reference)->removeObjectAtIndex(index); } - (void)replaceObjectAtIndex:(NSUInteger)index withObject:(id)anObject { - LGGOCXXSharedType object = [graphContext transmuteToGraphObject:anObject]; + LGGOCXXSharedReference objectAddress = [graphContext transmuteToGraphObject:anObject]; - std::tr1::dynamic_pointer_cast(sharedType)->replaceObjectAtIndexWithObject(object, index); + dynamic_cast(*reference)->replaceObjectAtIndexWithObject(objectAddress, index); } @end diff --git a/Source/objc/LGGONumber.h b/Source/objc/LGGONumber.h index f68d91a..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 LGGOCXXSharedType &)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 49339e6..11c39a7 100644 --- a/Source/objc/LGGONumber.mm +++ b/Source/objc/LGGONumber.mm @@ -24,56 +24,84 @@ 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 () { - LGGOCXXSharedType sharedType; + LGGOCXXSharedReference reference; LGGOGraphContext *graphContext; } -@property LGGOCXXSharedType sharedType; +@property (nonatomic, readonly) LGGOCXXSharedReference reference; @end @implementation LGGONumber -- (id)initWithNumber:(NSNumber *)number_ inContext:(LGGOGraphContext *)context_ { +- (id)initWithGraphObject:(const LGGOCXXSharedReference &)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) { + reference = graphObject; - + id existingObject = (id)reference->getNativeObject(); + + if (existingObject) { + reference = LGGOCXXSharedReference(); + [self release]; + retval = [existingObject retain]; + } else { + graphContext = [context_ retain]; + reference->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); + { + //LLVM/Clang 2.8 compiler bug work around + LGGOCXXSharedStoreContext context = context_.CXXContext; + reference = context->createNumber(number_.longLongValue); + } + + 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 + reference = LGGOCXXSharedReference(); + [self release]; + retval = [existingObject retain]; + } else { + retval = self; + graphContext = [context_ retain]; + reference->setNativeObject(self); + } } - - return self; + + return retval; } - (void) dealloc { + if (reference.isValid()) { + reference->setNativeObject(NULL); + } [graphContext release]; [super dealloc]; } - (void)getValue:(void *)value_ { - std::tr1::shared_ptr sharedNumber = std::tr1::dynamic_pointer_cast(sharedType); - switch(sharedNumber->getType()) { + LGGOCXXNumberRef *sharedNumber = dynamic_cast(*reference); + switch(sharedNumber->getNumberType()) { case kLGGOCXX8BitSignedNumberType: case kLGGOCXX16BitSignedNumberType: case kLGGOCXX32BitSignedNumberType: @@ -93,22 +121,22 @@ - (void)getValue:(void *)value_ { } } -#define LGGO_NUMBER_ACCESSOR(datatype, name) \ -- (datatype)name { \ - std::tr1::shared_ptr sharedNumber = std::tr1::dynamic_pointer_cast(sharedType); \ - 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 { \ + LGGOCXXNumberRef *sharedNumber = dynamic_cast(*reference); \ + datatype retval; \ + switch(sharedNumber->getNumberType()) { \ + 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) @@ -131,7 +159,7 @@ - (datatype)name { - (const char *)objCType { const char *retval; - switch(std::tr1::dynamic_pointer_cast(sharedType)->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.h b/Source/objc/LGGOString.h index ff9da93..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 LGGOCXXSharedType &)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 6f5b1a5..21801a9 100644 --- a/Source/objc/LGGOString.mm +++ b/Source/objc/LGGOString.mm @@ -21,66 +21,91 @@ 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 () { - LGGOCXXSharedType sharedType; + LGGOCXXSharedReference reference; LGGOGraphContext *graphContext; } -@property LGGOCXXSharedType sharedType; +@property (nonatomic, readonly) LGGOCXXSharedReference reference; @end @implementation LGGOString -- (id) initWithString:(NSString *)string_ inContext:(LGGOGraphContext *)context_ { - self = [super init]; - +- (id)initWithGraphObject:(const LGGOCXXSharedReference &)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); + reference = graphObject; + + id existingObject = (id)reference->getNativeObject(); + + if (existingObject) { + [self release]; + retval = [existingObject retain]; + } else { + graphContext = [context_ retain]; + reference->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); + { + //LLVM/Clang 2.8 compiler bug work around + LGGOCXXSharedStoreContext context = context_.CXXContext; + reference = context->createString(string_.UTF8String); + } + + id existingObject = (id)reference->getNativeObject(); + + if (existingObject) { + reference = LGGOCXXSharedReference(); + [self release]; + retval = [existingObject retain]; + } else { + retval = self; + graphContext = [context_ retain]; + reference->setNativeObject(self); + } } - - return self; + + return retval; } - (void) dealloc { + if (reference.isValid()) { + reference->setNativeObject(NULL); + } [graphContext release]; [super dealloc]; } -- (NSUInteger)length { - NSUInteger retval = std::tr1::dynamic_pointer_cast(sharedType)->getLength(); - - return retval; +- (NSUInteger)length { + return dynamic_cast(*reference)->getLength(); } - (unichar)characterAtIndex:(NSUInteger)index { - return std::tr1::dynamic_pointer_cast(sharedType)->getCharacterAtIndex(index); + return dynamic_cast(*reference)->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 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 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]; } }