/*Prints all data (transformation operations) contained by all the nodes to the screen*/
void printSequenceLst(sequenceLst*seqLst,int counter)
{
int i = 0;
if(seqLst!=NULL && counter>0)
{
seqLst->iterator = seqLst->head;
printf("\nSequence: ");
for (i = 0; i < counter; i++)
{
if (i == 0)
{
printf(" %i", getNodeData(seqLst->iterator));
}
else
{
printf("-%i", getNodeData(seqLst->iterator));
}
seqLst->iterator = seqLst->iterator->nextNode;
}
printf("\n");
}
else
{
printf("\nSequence: Not Applicable\n");
}
}
void test_inserts_elements_at_the_end_of_linkList_for_integer(){
int nums[3] = {10,12,14};
ASSERT(insert(&list, 0, &nums[0]));
ASSERT(insert(&list, 1, &nums[1]));
ASSERT(12 == *(int*)getNodeData(list, 1));
ASSERT(insert(&list, 2, &nums[2]));
ASSERT(14 == *(int*)getNodeData(list, 2));
ASSERT(3 == list.length);
}
void test_deletes_last_element_in_the_linkList(){
int nums[3] = {10,15,16};
insert(&list, 0, &nums[0]);
insert(&list, 1, &nums[1]);
insert(&list, 2, &nums[2]);
ASSERT(16 == *(int*)getNodeData(list, 2));
ASSERT(delete_node(&list, 2));
ASSERT(NULL == getNodeData(list, 2));
ASSERT(2 == list.length);
}
void test_adds_element_in_middle_of_linkList_integer(){
int nums[4] = {12,14,15,20};
ASSERT(insert(&list, 0, &nums[0]));
ASSERT(insert(&list, 1, &nums[2]));
ASSERT(insert(&list, 2, &nums[3]));
ASSERT(15 == *(int*)getNodeData(list, 1));
ASSERT(insert(&list, 1, &nums[1]));
ASSERT(14 == *(int*)getNodeData(list, 1));
ASSERT(4 == list.length);
}
bool P2pNode::fetchPeerList(ContextPtr connection) {
try {
COMMAND_HANDSHAKE::request request{ getNodeData(), getGenesisPayload() };
COMMAND_HANDSHAKE::response response;
OperationTimeout<P2pContext> timeout(m_dispatcher, *connection, m_cfg.getHandshakeTimeout());
connection->writeMessage(makeRequest(COMMAND_HANDSHAKE::ID, LevinProtocol::encode(request)));
LevinProtocol::Command cmd;
if (!connection->readCommand(cmd)) {
throw std::runtime_error("Connection closed unexpectedly");
}
if (!cmd.isResponse || cmd.command != COMMAND_HANDSHAKE::ID) {
throw std::runtime_error("Received unexpected reply");
}
if (!LevinProtocol::decode(cmd.buf, response)) {
throw std::runtime_error("Invalid reply format");
}
if (response.node_data.network_id != request.node_data.network_id) {
logger(ERROR) << *connection << "COMMAND_HANDSHAKE failed, wrong network: " << response.node_data.network_id;
return false;
}
return handleRemotePeerList(response.local_peerlist, response.node_data.local_time);
} catch (std::exception& e) {
logger(INFO) << *connection << "Failed to obtain peer list: " << e.what();
}
return false;
}
void test_deletes_first_element_in_list_with_one_element(){
int nums[1] = {10};
insert(&list, 0, nums);
ASSERT(delete_node(&list, 0));
ASSERT(0 == list.length);
ASSERT(NULL == getNodeData(list, 0));
}
void TplModelNode::restoreFromFile(QString filename, bool merge) {
QFile file(filename);
if (!file.open(QIODevice::ReadOnly)) {
QMessageBox::critical(NULL, tr("Server restore"), tr("Failed to open file %1 for server restoration").arg(filename), QMessageBox::Cancel);
return;
}
// need to clear all children
model.beginRemoveRows(getIndex(), 0, children.size()-1);
for(int i = children.size()-1; i >= 0; i--) {
TplModelNode *t = children.takeAt(i);
delete t;
}
model.endRemoveRows();
file_progress = true;
file_pos = 0;
file_total = 1;
model.dataChanged(getIndex(), getIndex());
QMap<QString, QVariant> request = getNodeData().toMap();
request["data"] = file.readAll().toBase64();
request["merge"] = merge;
QNetworkReply *reply = srv.sendRequest("Skins.restore", request, this, "handleRestoreResult", NULL);
srv.setUpProgressReceiver(reply, this);
}
void test_inserts_the_structures_in_the_linklist(){
Account accounts[3] = {{100,1000},{101,2000},{102,4000}};
ASSERT(insert(&list, 0, &accounts[0]));
ASSERT(insert(&list, 1, &accounts[1]));
ASSERT(insert(&list, 1, &accounts[2]));
ASSERT(areAccountsEqual(accounts[0], *(Account*)getNodeData(list, 0)));
ASSERT(3 == list.length);
}
void test_inserts_the_strings_in_the_linklist(){
String names[3] = {"prateek","Manish","Shweta"};
ASSERT(insert(&list, 0, &names[0]));
ASSERT(insert(&list, 1, &names[1]));
ASSERT(insert(&list, 1, &names[2]));
ASSERT(0 == strcmp("prateek", (char*)getNodeData(list, 0)));
ASSERT(3 == list.length);
}
void test_inserts_the_chars_in_the_linklist(){
char chars[3] = {'a','n','m'};
ASSERT(insert(&list, 0, &chars[0]));
ASSERT(insert(&list, 1, &chars[1]));
ASSERT(insert(&list, 1, &chars[2]));
ASSERT('n' == *(char*)getNodeData(list, 2));
ASSERT(3 == list.length);
}
void test_inserts_the_doubles_in_the_linklist(){
double nums[3] = {1.0,2.0,3.0};
ASSERT(insert(&list, 0, &nums[0]));
ASSERT(insert(&list, 1, &nums[1]));
ASSERT(insert(&list, 1, &nums[2]));
ASSERT(3.0 == *(double*)getNodeData(list, 1));
ASSERT(3 == list.length);
}
void test_inserts_multiple_element_as_the_head_of_linklist_for_integer(){
int nums[3] = {10,15,16};
ASSERT(insert(&list, 0, &nums[0]));
ASSERT(insert(&list, 0, &nums[1]));
ASSERT(insert(&list, 0, &nums[2]));
ASSERT(10 == *(int*)getNodeData(list, 2));
ASSERT(3 == list.length);
}
void TplModelNode::setTemplateType(QObject *target, const char *func, int tpl_type, QString options) {
QMap<QString, QVariant> query = getNodeData().toMap();
query["action"] = "TplType.setTemplateType";
query["Tpl_Type__"] = tpl_type;
query["Options"] = options;
srv.sendRequest(query["action"].toString(), query, target, func, NULL);
}
void SharedDataManager::setWarm(TreeDescriptor treeId, int nid, bool warm)
{
lock.lock();
SharedMemNodeData *nodeData = getNodeData(treeId, nid, true);
if(nodeData)
nodeData->setWarm(warm);
lock.unlock();
}
void SharedDataManager::setOwner(TreeDescriptor treeId, int nid, int ownerIdx, int timestamp)
{
lock.lock();
SharedMemNodeData *nodeData = getNodeData(treeId, nid, true);
if(nodeData)
nodeData->setOwner(ownerIdx, timestamp);
lock.unlock();
}
////////////////////////////////////////////////
//Cache coerency methods
////////////////////////////////////////////////
void SharedDataManager::getCoherencyInfo(TreeDescriptor treeId, int nid, bool &isOwner, int &ownerIdx, bool &isWarm, bool &isDirty, int ×tamp)
{
lock.lock();
SharedMemNodeData *nodeData = getNodeData(treeId, nid, true);
if(nodeData)
nodeData->getCoherencyInfo(isOwner, ownerIdx, isWarm, isDirty, timestamp);
lock.unlock();
}
void TplModelNode::setPageProperties(QObject *target, const char *func, QString charset, QString content_type) {
QMap<QString, QVariant> query = getNodeData().toMap();
query["action"] = "Skins.setPageProperties";
query["Charset"] = charset;
query["Content_Type"] = content_type;
srv.sendRequest(query["action"].toString(), query, target, func, NULL);
}
void SharedDataManager::getSerialized(TreeDescriptor treeId, int nid, char *serialized)
{
lock.lock();
SharedMemNodeData *nodeData = getNodeData(treeId, nid, true);
if(nodeData)
nodeData->getSerialized(serialized);
lock.unlock();
}
void SharedDataManager::setDirty(TreeDescriptor treeId, int nid, bool isDirty)
{
lock.lock();
SharedMemNodeData *nodeData = getNodeData(treeId, nid, true);
if(nodeData)
nodeData->setDirty(isDirty);
lock.unlock();
}
void SharedDataManager::addWarm(TreeDescriptor treeId, int nid, int warmIdx)
{
lock.lock();
SharedMemNodeData *nodeData = getNodeData(treeId, nid, true);
if(nodeData)
nodeData->addWarm(warmIdx);
lock.unlock();
}
int outputList (list_t list) {
if (list == NULL || list->firstNodePtr == NULL) { // list safety
printf("ERROR: deleteFirst: no list or no firstNode\n");
return 0;
}else {
FILE *file;
struct tm *tvar;
// "dynamic" filename
time_t tnow = time(NULL);
tvar = localtime(&tnow);
char filename[40];
sprintf(filename, "prpOutput_%04i%02i%02iT%02i%02i%02i.csv", tvar->tm_year+1900, tvar->tm_mon+1, tvar->tm_mday, tvar->tm_hour, tvar->tm_min, tvar->tm_sec);
file = fopen(filename, "w");
if (file == NULL) { // output safety
printf("ERROR: outputListe: can not create file output\n");
return 0;
}else {// normal operation
fprintf(file, "item No.; input time; height ok (Y/N); metal (Y/N); output time\n");
printf( "\nitem No.; input time; height ok (Y/N); metal (Y/N); output time\n");
for (int i = 1; i <= list->length; i++) {//every node
listDataPtr data = getNodeData(list, i);
// print item number
fprintf(file, "%02i;", i);
printf("%02i; ", i);
tvar = localtime(&data->inputTime);
fprintf(file, "%04i-%02i-%02i T%02i:%02i:%02i;",tvar->tm_year+1900, tvar->tm_mon+1, tvar->tm_mday, tvar->tm_hour, tvar->tm_min, tvar->tm_sec);
printf("%04i-%02i-%02i T%02i:%02i:%02i; ",tvar->tm_year+1900, tvar->tm_mon+1, tvar->tm_mday, tvar->tm_hour, tvar->tm_min, tvar->tm_sec);
fprintf(file, "%i;", (Boolean) data->height);
printf("%i; ", (Boolean) data->height);
fprintf(file, "%i;", (Boolean) data->metal);
printf("%i; ", (Boolean) data->metal);
tvar = localtime(&data->outputTime);
fprintf(file, "%04i-%02i-%02i T%02i:%02i:%02i;",tvar->tm_year+1900, tvar->tm_mon+1, tvar->tm_mday, tvar->tm_hour, tvar->tm_min, tvar->tm_sec);
printf("%04i-%02i-%02i T%02i:%02i:%02i; ",tvar->tm_year+1900, tvar->tm_mon+1, tvar->tm_mday, tvar->tm_hour, tvar->tm_min, tvar->tm_sec);
fprintf(file, "\n");
printf("\n");
}
fclose(file);
printf("\n");
printf("INFO: list saved\n");
printf("\n\n");
}// end output safety
return 1;
}// end list safety
}
XalanDOMString
DOMServices::getNodeData(const XalanElement& element)
{
XalanDOMString data;
getNodeData(element, data);
return data;
}
void test_deletes_element_in_between(){
int nums[3] = {10,15,16};
insert(&list, 0, &nums[0]);
insert(&list, 1, &nums[1]);
insert(&list, 2, &nums[2]);
ASSERT(16 == *(int*)getNodeData(list, 2));
ASSERT(delete_node(&list, 1));
ASSERT(2 == list.length);
}
void TplModelNode::serverRelocate(TplModelNode *newparent) {
if (getType() != FILE) return;
if (newparent == parent) return; // ignore it
QMap<QString, QVariant> req = getNodeData().toMap();
req["NewLocation"] = newparent->getNodeData();
srv.sendRequest("System.moveFile", req, this, "serverRelocateResult", newparent);
}
XalanDOMString
DOMServices::getNodeData(const XalanNode& node)
{
XalanDOMString data;
getNodeData(node, data);
return data;
}
void test_deletes_first_element_in_list_when_more_than_one_elements(){
int nums[3] = {10,15,16};
insert(&list, 0, &nums[0]);
insert(&list, 1, &nums[1]);
insert(&list, 2, &nums[2]);
ASSERT(delete_node(&list, 0));
ASSERT(NULL == getNodeData(list, 2));
ASSERT(2 == list.length);
}
XalanDOMString
DOMServices::getNodeData(const XalanDocumentFragment& documentFragment)
{
XalanDOMString data;
getNodeData(documentFragment, data);
return data;
}
SemEvent *SharedDataManager::getDataEvent(TreeDescriptor treeId, int nid)
{
lock.lock();
SharedMemNodeData *nodeData = getNodeData(treeId, nid, true);
SemEvent *retEv = NULL;
if(nodeData)
retEv = nodeData->getDataEvent();
lock.unlock();
return retEv;
}
void SharedDataManager::setCoherencyInfo(TreeDescriptor treeId, int nid, bool isOwner, int ownerIdx, bool isWarm, int timestamp,
char *warmNodes, int numWarmNodes, char *readerNodes, int numReaderNodes)
{
lock.lock();
SharedMemNodeData *nodeData = getNodeData(treeId, nid, true);
if(nodeData)
nodeData->setCoherencyInfo(isOwner, ownerIdx, isWarm, timestamp,warmNodes, numWarmNodes,
readerNodes, numReaderNodes);
lock.unlock();
}
bool SharedDataManager::isWarm(TreeDescriptor treeId, int nid)
{
lock.lock();
SharedMemNodeData *nodeData = getNodeData(treeId, nid, true);
bool warm = false;
if(nodeData)
warm = nodeData->isWarm();
lock.unlock();
return warm;
}
