Untitled

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)
+* 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)

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<void *>(&address);

Source/Storage/LGGOCXXMemoryDescriptor.h

@@ -36,7 +36,7 @@ extern LGGOCXXSharedMemoryDescriptor NULL_DESCRIPTOR;
 
 #include <assert.h>
 
-#include "LGGOCXXAddress.h"
+#include "LGGOCXXReferenceMetadata.h"
 #include "LGGOCXXStoreHash.h"
 
 virtual class LGGOCXXCoreMemoryDescriptor : public std::tr1::enable_shared_from_this<LGGOCXXCoreMemoryDescriptor> {
@@ -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);

Source/Storage/LGGOCXXStoreContext.cpp

@@ -26,118 +26,122 @@
 
 #include <sstream>
 
-#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<LGGOCXXAddress,LGGOCXXSharedType>::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<uint64_t,LGGOCXXWeakReference>::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<uint64_t, LGGOCXXWeakReference>(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<uint64_t,LGGOCXXWeakReference>::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<LGGOCXXSharedStoreSegment>::iterator i;
+  for (i = segments.begin(); i != segments.end(); ++i) {
+    retval = (*i)->getDescriptorForAddress(address);
 
-      std::vector<LGGOCXXSharedStoreSegment>::iterator i;
-      for (i = segments.begin(); i != segments.end(); ++i) {
-        descriptor = writableSegment->getDescriptorForAddress(address);
-
-        if (descriptor.get() != NULL) {
-          break;
-        }
-      }
+    if (retval.get() != NULL) {
+      break;
     }
   }
 

Source/Storage/LGGOCXXStoreContext.h

@@ -34,44 +34,46 @@ typedef std::tr1::weak_ptr<LGGOCXXStoreContext> LGGOCXXWeakStoreContext;
 #define LGGOCXXSTORECONTEXT_H
 
 #include <vector>
+#include <map>
 
+#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<LGGOCXXStoreContext> {
 private:
   LGGOCXXSharedStore store;
-  LGGOCXXWritableStoreSegment *writableSegment;
+//  LGGOCXXWritableStoreSegment *writableSegment;
   std::vector<LGGOCXXSharedStoreSegment> segments;
   uint64_t nextAddressValue;
-   void (*nativeReleaseFunc)(void *);
-   void (*nativeRetainFunc)(void *);
 
+  std::map<uint64_t,LGGOCXXWeakReference> addresses;
   //FIXME this should be weak, but without native types that can bump shared_ptrs it needs to be strong for now
-  std::map<LGGOCXXAddress,LGGOCXXSharedType> 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

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<LGGOCXXAddress,LGGOCXXSharedMemoryDescriptor>::iterator i = memoryObjects.find(address);
+  std::map<LGGOCXXReferenceMetadata,LGGOCXXSharedMemoryDescriptor>::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<LGGOCXXSharedStoreHash, LGGOCXXSharedMemoryDescriptor> hashMap;
   std::vector<std::tr1::tuple<uint64_t, uint64_t, LGGOCXXSharedMemoryDescriptor> > compressedDecriptors;
-  std::map<LGGOCXXAddress,LGGOCXXSharedMemoryDescriptor>::iterator i;
+  std::map<LGGOCXXReferenceMetadata,LGGOCXXSharedMemoryDescriptor>::iterator i;
   std::map<LGGOCXXSharedStoreHash, LGGOCXXSharedMemoryDescriptor>::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));
-}
+}
+#endif