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;
}
