DATA_PUBLISHER_RESULT DataPublisher_CancelTransaction(TRANSACTION_HANDLE transactionHandle)
{
DATA_PUBLISHER_RESULT result;
if (transactionHandle == NULL)
{
/* Codes_SRS_DATA_PUBLISHER_99_014:[ If the transactionHandle argument is NULL DataPublisher_CancelTransaction shall return DATA_PUBLISHER_INVALID_ARG.] */
result = DATA_PUBLISHER_INVALID_ARG;
LOG_DATA_PUBLISHER_ERROR;
}
else
{
TRANSACTION* transaction = (TRANSACTION*)transactionHandle;
size_t i;
/* Codes_SRS_DATA_PUBLISHER_99_015:[ DataPublisher_CancelTransaction shall dispose of any resources associated with the transaction.] */
for (i = 0; i < transaction->ValueCount; i++)
{
Destroy_AGENT_DATA_TYPE((AGENT_DATA_TYPE*)transaction->Values[i].Value);
free((char*)transaction->Values[i].PropertyPath);
free((AGENT_DATA_TYPE*)transaction->Values[i].Value);
}
/* Codes_SRS_DATA_PUBLISHER_99_015:[ DataPublisher_CancelTransaction shall dispose of any resources associated with the transaction.] */
free(transaction->Values);
free(transaction);
/* Codes_SRS_DATA_PUBLISHER_99_013:[ A call to DataPublisher_CancelTransaction shall dispose of the transaction without dispatching
the data to the DataMarshaller module and it shall return DATA_PUBLISHER_OK.] */
result = DATA_PUBLISHER_OK;
}
return result;
}
void DataPublisher_DestroyTransaction_ReportedProperties(REPORTED_PROPERTIES_TRANSACTION_HANDLE transactionHandle)
{
/*Codes_SRS_DATA_PUBLISHER_02_025: [ If argument transactionHandle is NULL then DataPublisher_DestroyTransaction_ReportedProperties shall return. ]*/
if (transactionHandle == NULL)
{
LogError("invalig argument REPORTED_PROPERTIES_TRANSACTION_HANDLE transactionHandle=%p", transactionHandle);
}
else
{
/*Codes_SRS_DATA_PUBLISHER_02_026: [ Otherwise DataPublisher_DestroyTransaction_ReportedProperties shall free all resources associated with the reported properties transactionHandle. ]*/
REPORTED_PROPERTIES_TRANSACTION_HANDLE_DATA* handleData = (REPORTED_PROPERTIES_TRANSACTION_HANDLE_DATA*)transactionHandle;
size_t i, nReportedProperties;
nReportedProperties = VECTOR_size(handleData->value);
for (i = 0;i < nReportedProperties;i++)
{
DATA_MARSHALLER_VALUE *value = *(DATA_MARSHALLER_VALUE**)VECTOR_element(handleData->value, i);
Destroy_AGENT_DATA_TYPE((AGENT_DATA_TYPE*)value->Value);
free((void*)value->Value);
free((void*)value->PropertyPath);
free((void*)value);
}
VECTOR_destroy(handleData->value);
free(handleData);
}
return;
}
DATA_PUBLISHER_RESULT DataPublisher_PublishTransacted(TRANSACTION_HANDLE transactionHandle, const char* propertyPath, const AGENT_DATA_TYPE* data)
{
DATA_PUBLISHER_RESULT result;
char* propertyPathCopy;
/* Codes_SRS_DATA_PUBLISHER_99_017:[ When one or more NULL parameter(s) are specified, DataPublisher_PublishTransacted is called with a NULL transactionHandle, it shall return DATA_PUBLISHER_INVALID_ARG.] */
if ((transactionHandle == NULL) ||
(propertyPath == NULL) ||
(data == NULL))
{
result = DATA_PUBLISHER_INVALID_ARG;
LOG_DATA_PUBLISHER_ERROR;
}
else if (mallocAndStrcpy_s(&propertyPathCopy, propertyPath) != 0)
{
/* Codes_SRS_DATA_PUBLISHER_99_020:[ For any errors not explicitly mentioned here the DataPublisher APIs shall return DATA_PUBLISHER_ERROR.] */
result = DATA_PUBLISHER_ERROR;
LOG_DATA_PUBLISHER_ERROR;
}
else
{
TRANSACTION* transaction = (TRANSACTION*)transactionHandle;
AGENT_DATA_TYPE* propertyValue;
if (!Schema_ModelPropertyByPathExists(transaction->DataPublisherInstance->ModelHandle, propertyPath))
{
free(propertyPathCopy);
/* Codes_SRS_DATA_PUBLISHER_99_040:[ When propertyPath does not exist in the supplied model, DataPublisher_Publish shall return DATA_PUBLISHER_SCHEMA_FAILED without dispatching data.] */
result = DATA_PUBLISHER_SCHEMA_FAILED;
LOG_DATA_PUBLISHER_ERROR;
}
else if ((propertyValue = (AGENT_DATA_TYPE*)malloc(sizeof(AGENT_DATA_TYPE))) == NULL)
{
free(propertyPathCopy);
/* Codes_SRS_DATA_PUBLISHER_99_020:[ For any errors not explicitly mentioned here the DataPublisher APIs shall return DATA_PUBLISHER_ERROR.] */
result = DATA_PUBLISHER_ERROR;
LOG_DATA_PUBLISHER_ERROR;
}
else if (Create_AGENT_DATA_TYPE_from_AGENT_DATA_TYPE(propertyValue, data) != AGENT_DATA_TYPES_OK)
{
free(propertyPathCopy);
free(propertyValue);
/* Codes_SRS_DATA_PUBLISHER_99_028:[ If creating the copy fails then DATA_PUBLISHER_AGENT_DATA_TYPES_ERROR shall be returned.] */
result = DATA_PUBLISHER_AGENT_DATA_TYPES_ERROR;
LOG_DATA_PUBLISHER_ERROR;
}
else
{
size_t i;
DATA_MARSHALLER_VALUE* propertySlot = NULL;
/* Codes_SRS_DATA_PUBLISHER_99_019:[ If the same property is associated twice with a transaction, then the last value shall be kept associated with the transaction.] */
for (i = 0; i < transaction->ValueCount; i++)
{
if (strcmp(transaction->Values[i].PropertyPath, propertyPath) == 0)
{
propertySlot = &transaction->Values[i];
break;
}
}
if (propertySlot == NULL)
{
DATA_MARSHALLER_VALUE* newValues = (DATA_MARSHALLER_VALUE*)realloc(transaction->Values, sizeof(DATA_MARSHALLER_VALUE)* (transaction->ValueCount + 1));
if (newValues != NULL)
{
transaction->Values = newValues;
propertySlot = &transaction->Values[transaction->ValueCount];
propertySlot->Value = NULL;
propertySlot->PropertyPath = NULL;
transaction->ValueCount++;
}
}
if (propertySlot == NULL)
{
Destroy_AGENT_DATA_TYPE((AGENT_DATA_TYPE*)propertyValue);
free(propertyValue);
free(propertyPathCopy);
/* Codes_SRS_DATA_PUBLISHER_99_020:[ For any errors not explicitly mentioned here the DataPublisher APIs shall return DATA_PUBLISHER_ERROR.] */
result = DATA_PUBLISHER_ERROR;
LOG_DATA_PUBLISHER_ERROR;
}
else
{
if (propertySlot->Value != NULL)
{
Destroy_AGENT_DATA_TYPE((AGENT_DATA_TYPE*)propertySlot->Value);
free((AGENT_DATA_TYPE*)propertySlot->Value);
}
if (propertySlot->PropertyPath != NULL)
{
char* existingValue = (char*)propertySlot->PropertyPath;
free(existingValue);
}
/* Codes_SRS_DATA_PUBLISHER_99_016:[ When DataPublisher_PublishTransacted is invoked, DataPublisher shall associate the data with the transaction identified by the transactionHandle argument and return DATA_PUBLISHER_OK. No data shall be dispatched at the time of the call.] */
propertySlot->PropertyPath = propertyPathCopy;
propertySlot->Value = propertyValue;
result = DATA_PUBLISHER_OK;
}
}
}
return result;
}
DATA_PUBLISHER_RESULT DataPublisher_PublishTransacted_ReportedProperty(REPORTED_PROPERTIES_TRANSACTION_HANDLE transactionHandle, const char* reportedPropertyPath, const AGENT_DATA_TYPE* data)
{
DATA_PUBLISHER_RESULT result;
/*Codes_SRS_DATA_PUBLISHER_02_009: [ If argument transactionHandle is NULL then DataPublisher_PublishTransacted_ReportedProperty shall fail and return DATA_PUBLISHER_INVALID_ARG. ]*/
/*Codes_SRS_DATA_PUBLISHER_02_010: [ If argument reportedPropertyPath is NULL then DataPublisher_PublishTransacted_ReportedProperty shall fail and return DATA_PUBLISHER_INVALID_ARG. ]*/
/*Codes_SRS_DATA_PUBLISHER_02_011: [ If argument data is NULL then DataPublisher_PublishTransacted_ReportedProperty shall fail and return DATA_PUBLISHER_INVALID_ARG. ]*/
if (
(transactionHandle == NULL) ||
(reportedPropertyPath == NULL) ||
(data == NULL)
)
{
LogError("invalid argument REPORTED_PROPERTIES_TRANSACTION_HANDLE transactionHandle=%p, const char* reportedPropertyPath=%p, const AGENT_DATA_TYPE* data=%p", transactionHandle, reportedPropertyPath, data);
result = DATA_PUBLISHER_INVALID_ARG;
}
else
{
REPORTED_PROPERTIES_TRANSACTION_HANDLE_DATA* handleData = (REPORTED_PROPERTIES_TRANSACTION_HANDLE_DATA*)transactionHandle;
/*Codes_SRS_DATA_PUBLISHER_02_012: [ DataPublisher_PublishTransacted_ReportedProperty shall verify that a reported property having the path reportedPropertyPath exists in the model by calling Schema_ModelReportedPropertyByPathExists ]*/
if (!Schema_ModelReportedPropertyByPathExists(handleData->DataPublisherInstance->ModelHandle, reportedPropertyPath))
{
/*Codes_SRS_DATA_PUBLISHER_02_013: [ If a reported property with path reportedPropertyPath does not exist in the model then DataPublisher_PublishTransacted_ReportedProperty shall fail and return DATA_PUBLISHER_INVALID_ARG. ]*/
LogError("unable to find a reported property by path \"%s\"", reportedPropertyPath);
result = DATA_PUBLISHER_INVALID_ARG;
}
else
{
DATA_MARSHALLER_VALUE** existingValue = VECTOR_find_if(handleData->value, reportedPropertyExistsByPath, reportedPropertyPath);
if(existingValue != NULL)
{
/*Codes_SRS_DATA_PUBLISHER_02_014: [ If the same (by reportedPropertypath) reported property has already been added to the transaction, then DataPublisher_PublishTransacted_ReportedProperty shall overwrite the previous reported property. ]*/
AGENT_DATA_TYPE *clone = (AGENT_DATA_TYPE *)malloc(sizeof(AGENT_DATA_TYPE));
if(clone == NULL)
{
/*Codes_SRS_DATA_PUBLISHER_02_016: [ If any error occurs then DataPublisher_PublishTransacted_ReportedProperty shall fail and return DATA_PUBLISHER_ERROR. ]*/
LogError("unable to malloc");
result = DATA_PUBLISHER_ERROR;
}
else
{
if (Create_AGENT_DATA_TYPE_from_AGENT_DATA_TYPE(clone, data) != AGENT_DATA_TYPES_OK)
{
/*Codes_SRS_DATA_PUBLISHER_02_016: [ If any error occurs then DataPublisher_PublishTransacted_ReportedProperty shall fail and return DATA_PUBLISHER_ERROR. ]*/
LogError("unable to Create_AGENT_DATA_TYPE_from_AGENT_DATA_TYPE");
free(clone);
result = DATA_PUBLISHER_ERROR;
}
else
{
/*Codes_SRS_DATA_PUBLISHER_02_017: [ Otherwise DataPublisher_PublishTransacted_ReportedProperty shall succeed and return DATA_PUBLISHER_OK. ]*/
Destroy_AGENT_DATA_TYPE((AGENT_DATA_TYPE*)((*existingValue)->Value));
free((void*)((*existingValue)->Value));
(*existingValue)->Value = clone;
result = DATA_PUBLISHER_OK;
}
}
}
else
{
/*totally new reported property*/
DATA_MARSHALLER_VALUE* newValue = (DATA_MARSHALLER_VALUE*)malloc(sizeof(DATA_MARSHALLER_VALUE));
if (newValue == NULL)
{
/*Codes_SRS_DATA_PUBLISHER_02_016: [ If any error occurs then DataPublisher_PublishTransacted_ReportedProperty shall fail and return DATA_PUBLISHER_ERROR. ]*/
LogError("unable to malloc");
result = DATA_PUBLISHER_ERROR;
}
else
{
if (mallocAndStrcpy_s((char**)&(newValue->PropertyPath), reportedPropertyPath) != 0)
{
/*Codes_SRS_DATA_PUBLISHER_02_016: [ If any error occurs then DataPublisher_PublishTransacted_ReportedProperty shall fail and return DATA_PUBLISHER_ERROR. ]*/
LogError("unable to mallocAndStrcpy_s");
free(newValue);
result = DATA_PUBLISHER_ERROR;
}
else
{
if ((newValue->Value = (AGENT_DATA_TYPE*)malloc(sizeof(AGENT_DATA_TYPE))) == NULL)
{
LogError("unable to malloc");
free((void*)newValue->PropertyPath);
free(newValue);
result = DATA_PUBLISHER_ERROR;
}
else
{
if (Create_AGENT_DATA_TYPE_from_AGENT_DATA_TYPE((AGENT_DATA_TYPE*)newValue->Value, data) != AGENT_DATA_TYPES_OK)
{
/*Codes_SRS_DATA_PUBLISHER_02_016: [ If any error occurs then DataPublisher_PublishTransacted_ReportedProperty shall fail and return DATA_PUBLISHER_ERROR. ]*/
LogError("unable to Create_AGENT_DATA_TYPE_from_AGENT_DATA_TYPE");
free((void*)newValue->Value);
free((void*)newValue->PropertyPath);
free(newValue);
result = DATA_PUBLISHER_ERROR;
}
else
{
/*Codes_SRS_DATA_PUBLISHER_02_015: [ DataPublisher_PublishTransacted_ReportedProperty shall add a new DATA_MARSHALLER_VALUE to the VECTOR_HANDLE. ]*/
if (VECTOR_push_back(handleData->value, &newValue, 1) != 0)
{
/*Codes_SRS_DATA_PUBLISHER_02_016: [ If any error occurs then DataPublisher_PublishTransacted_ReportedProperty shall fail and return DATA_PUBLISHER_ERROR. */
LogError("unable to VECTOR_push_back");
Destroy_AGENT_DATA_TYPE((AGENT_DATA_TYPE*)newValue->Value);
free((void*)newValue->Value);
free((void*)newValue->PropertyPath);
free(newValue);
result = DATA_PUBLISHER_ERROR;
}
else
{
/*Codes_SRS_DATA_PUBLISHER_02_017: [ Otherwise DataPublisher_PublishTransacted_ReportedProperty shall succeed and return DATA_PUBLISHER_OK. ]*/
result = DATA_PUBLISHER_OK;
}
}
}
}
}
}
}
}
return result;
}
