bool CBInitStringByCopyingCString(CBString * self,char * string){ self->string = malloc(strlen(string)); strcpy(self->string,string); if (!CBInitObject(CBGetObject(self))) return false; return true; }
void CBInitByteArraySubReference(CBByteArray * self, CBByteArray * ref, uint32_t offset, uint32_t length) { CBInitObject(CBGetObject(self), false); self->sharedData = ref->sharedData; self->sharedData->references++; // Since a new reference to the shared data is being made, an increase in the reference count must be made. self->length = length; self->offset = ref->offset + offset; }
CBString * CBNewStringByTakingCString(char * string){ objectNum++; CBString * self = malloc(sizeof(*self)); CBAddVTToObject(CBGetObject(self), &VTStore, CBCreateStringVT); CBInitStringByTakingCString(self,string); return self; }
CBScript * CBNewScript(CBNetworkParameters * params,CBByteArray * program,CBEvents * events){ CBScript * self = malloc(sizeof(*self)); objectNum++; CBAddVTToObject(CBGetObject(self), &VTStore, CBCreateScriptVT); CBInitScript(self,params,program,events); return self; }
CBNode * CBNewNode(CBDepObject database, CBNodeFlags flags, CBNodeCallbacks nodeCallbacks, CBNetworkCommunicatorCallbacks commCallbacks, CBOnMessageReceivedAction (*onMessageReceived)(CBNode *, CBPeer *, CBMessage *)){ CBNode * self = malloc(sizeof(*self)); CBGetObject(self)->free = CBFreeNode; if (CBInitNode(self, database, flags, nodeCallbacks, commCallbacks, onMessageReceived)) return self; free(self); return NULL; }
void CBInitByteArrayWithData(CBByteArray * self, uint8_t * data, uint32_t size) { CBInitObject(CBGetObject(self), false); self->sharedData = malloc(sizeof(*self->sharedData)); self->sharedData->data = data; self->sharedData->references = 1; self->length = size; self->offset = 0; }
CBBlockHeaders * CBNewBlockHeadersFromData(CBByteArray * data) { CBBlockHeaders * self = malloc(sizeof(*self)); CBGetObject(self)->free = CBFreeBlockHeaders; CBInitBlockHeadersFromData(self, data); return self; }
CBBlockHeaders * CBNewBlockHeaders() { CBBlockHeaders * self = malloc(sizeof(*self)); CBGetObject(self)->free = CBFreeBlockHeaders; CBInitBlockHeaders(self); return self; }
CBInventory * CBNewInventoryFromData(CBByteArray * data) { CBInventory * self = malloc(sizeof(*self)); CBGetObject(self)->free = CBFreeInventory; CBInitInventoryFromData(self, data); return self; }
CBInventory * CBNewInventory() { CBInventory * self = malloc(sizeof(*self)); CBGetObject(self)->free = CBFreeInventory; CBInitInventory(self); return self; }
void CBInitByteArrayFromString(CBByteArray * self, char * string, bool terminator) { CBInitObject(CBGetObject(self), false); self->length = (uint32_t)(strlen(string) + terminator); self->sharedData = malloc(sizeof(*self->sharedData)); self->sharedData->data = malloc(self->length); self->sharedData->references = 1; self->offset = 0; memcpy(self->sharedData->data, string, self->length); }
CBAlert * CBNewAlert(int32_t version, int64_t relayUntil, int64_t expiration, int32_t ID, int32_t cancel, int32_t minVer, int32_t maxVer, int32_t priority, CBByteArray * hiddenComment, CBByteArray * displayedComment, CBByteArray * reserved) { CBAlert * self = malloc(sizeof(*self)); CBGetObject(self)->free = CBFreeAlert; CBInitAlert(self, version, relayUntil, expiration, ID, cancel, minVer, maxVer, priority, hiddenComment, displayedComment, reserved); return self; }
CBAlert * CBNewAlertFromData(CBByteArray * data) { CBAlert * self = malloc(sizeof(*self)); CBGetObject(self)->free = CBFreeAlert; CBInitAlertFromData(self, data); return self; }
CBPingPong * CBNewPingPongFromData(CBByteArray * data) { CBPingPong * self = malloc(sizeof(*self)); CBGetObject(self)->free = CBFreePingPong; CBInitPingPongFromData(self, data); return self; }
CBPingPong * CBNewPingPong(long long int ID) { CBPingPong * self = malloc(sizeof(*self)); CBGetObject(self)->free = CBFreePingPong; CBInitPingPong(self, ID); return self; }
CBVersionChecksumBytes * CBNewVersionChecksumBytesFromString(CBByteArray * string,bool cacheString,CBEvents * events){ CBVersionChecksumBytes * self = malloc(sizeof(*self)); CBGetObject(self)->free = CBFreeVersionChecksumBytes; bool ok = CBInitVersionChecksumBytesFromString(self,string,cacheString,events); if (NOT ok) { return NULL; } return self; }
bool CBInitMessageByObject(CBMessage * self,void (*onErrorReceived)(CBError error,char *,...)){ if (NOT CBInitObject(CBGetObject(self))) return false; self->bytes = NULL; self->onErrorReceived = onErrorReceived; self->expectResponse = false; self->serialised = false; return true; }
void CBFreeTransaction(void * vself){ CBTransaction * self = vself; for (uint32_t x = 0; x < self->inputNum; x++) CBReleaseObject(self->inputs[x]); free(self->inputs); for (uint32_t x = 0; x < self->outputNum; x++) CBReleaseObject(self->outputs[x]); free(self->outputs); CBFreeMessage(CBGetObject(self)); }
bool CBInitByteArraySubReference(CBByteArray * self,CBByteArray * ref,uint32_t offset,uint32_t length){ if (NOT CBInitObject(CBGetObject(self))) return false; self->logError = ref->logError; self->sharedData = ref->sharedData; self->sharedData->references++; // Since a new reference to the shared data is being made, an increase in the reference count must be made. self->length = length; self->offset = ref->offset + offset; return true; }
bool CBInitMessageByData(CBMessage * self,CBByteArray * data,void (*onErrorReceived)(CBError error,char *,...)){ if (NOT CBInitObject(CBGetObject(self))) return false; self->bytes = data; CBRetainObject(data); // Retain data for this object. self->onErrorReceived = onErrorReceived; self->expectResponse = false; self->serialised = true; return true; }
void CBInitByteArrayOfSize(CBByteArray * self, uint32_t size) { CBInitObject(CBGetObject(self), false); self->length = size; self->offset = 0; if (size) { self->sharedData = malloc(sizeof(*self->sharedData)); self->sharedData->references = 1; self->sharedData->data = malloc(size); } else self->sharedData = NULL; }
CBTransaction * CBNewTransactionFromData(CBByteArray * bytes){ CBTransaction * self = malloc(sizeof(*self)); if (NOT self) { CBLogError("Cannot allocate %i bytes of memory in CBNewTransactionFromData\n", sizeof(*self)); return NULL; } CBGetObject(self)->free = CBFreeTransaction; if(CBInitTransactionFromData(self, bytes)) return self; free(self); return NULL; }
CBTransaction * CBNewTransaction(uint32_t lockTime, uint32_t version){ CBTransaction * self = malloc(sizeof(*self)); if (NOT self) { CBLogError("Cannot allocate %i bytes of memory in CBNewTransaction\n", sizeof(*self)); return NULL; } CBGetObject(self)->free = CBFreeTransaction; if(CBInitTransaction(self, lockTime, version)) return self; free(self); return NULL; }
CBAddress * CBNewAddressFromString(CBByteArray * string,bool cacheString,void (*logError)(char *,...)){ CBAddress * self = malloc(sizeof(*self)); if (NOT self) { logError("Cannot allocate %i bytes of memory in CBNewAddressFromString\n",sizeof(*self)); return NULL; } CBGetObject(self)->free = CBFreeAddress; if (CBInitAddressFromString(self,string,cacheString,logError)) return self; free(self); return NULL; }
CBAddress * CBNewAddressFromRIPEMD160Hash(uint8_t * hash,uint8_t networkCode,bool cacheString,void (*logError)(char *,...)){ CBAddress * self = malloc(sizeof(*self)); if (NOT self) { logError("Cannot allocate %i bytes of memory in CBNewAddressFromRIPEMD160Hash\n",sizeof(*self)); return NULL; } CBGetObject(self)->free = CBFreeAddress; if (CBInitAddressFromRIPEMD160Hash(self,networkCode,hash,cacheString,logError)) return self; free(self); return NULL; }
CBBlockHeaders * CBNewBlockHeadersFromData(CBByteArray * data,void (*logError)(char *,...)) { CBBlockHeaders * self = malloc(sizeof(*self)); if (NOT self) { logError("Cannot allocate %i bytes of memory in CBNewBlockHeadersFromData\n",sizeof(*self)); return NULL; } CBGetObject(self)->free = CBFreeBlockHeaders; if(CBInitBlockHeadersFromData(self,data,logError)) return self; free(self); return NULL; }
CBTransactionOutput * CBNewTransactionOutput(uint64_t value, CBScript * script){ CBTransactionOutput * self = malloc(sizeof(*self)); if (NOT self) { CBLogError("Cannot allocate %i bytes of memory in CBNewTransactionOutput\n", sizeof(*self)); return NULL; } CBGetObject(self)->free = CBFreeTransactionOutput; if(CBInitTransactionOutput(self, value, script)) return self; free(self); return NULL; }
CBVersionChecksumBytes * CBNewVersionChecksumBytesFromBytes(uint8_t * bytes,uint32_t size,bool cacheString,void (*logError)(char *,...)) { CBVersionChecksumBytes * self = malloc(sizeof(*self)); if (NOT self) { logError("Cannot allocate %i bytes of memory in CBNewVersionChecksumBytesFromBytes\n",sizeof(*self)); return NULL; } CBGetObject(self)->free = CBFreeVersionChecksumBytes; if(CBInitVersionChecksumBytesFromBytes(self,bytes,size,cacheString,logError)) return self; free(self); return NULL; }
CBMessage * CBNewMessageByObject(void (*onErrorReceived)(CBError error,char *,...)){ CBMessage * self = malloc(sizeof(*self)); if (NOT self) { onErrorReceived(CB_ERROR_OUT_OF_MEMORY,"Cannot allocate %i bytes of memory in CBNewMessageByObject\n",sizeof(*self)); return NULL; } CBGetObject(self)->free = CBFreeMessage; if (CBInitMessageByObject(self,onErrorReceived)) return self; free(self); return NULL; }
BEFullNode * BENewFullNode(void (*onErrorReceived)(CBError error,char *,...)){ BEFullNode * self = malloc(sizeof(*self)); if (NOT self) { onErrorReceived(CB_ERROR_OUT_OF_MEMORY,"Cannot allocate %i bytes of memory in BENewFullNode\n",sizeof(*self)); return NULL; } CBGetObject(self)->free = BEFreeFullNode; if (BEInitFullNode(self,onErrorReceived)) return self; free(self); return NULL; }