Input multiple data types from a file into a linked list - C / C++ / MFC Discussion Boards

This needs to be done properly but lets see if we can get this at least going, so let me guess at the next problem what is Transdata?

You loop in some sort of weird poll loop 100 times and call Transdata.Init ... if that is a constructor you just made 100 transdata and you never dispose of them. Check if it is your responsibility to dispose of TransData. However you can pull up windows resource manager and see if your client program memory growing and growing and growing because that will be the source and rather quickly. You don't dispose of transdata and if what I fear is true your program will leak memory like a sponge.

I actually can't get why you even need transdata, can't you just send the receive data to your buffer EsimData

Wouldn't something like
ReceiveData(&Esimdata[nEnd]);
put the read data directly where you need it without the the need for transdata. I don't know what EsimData is so the format may not be right but explain why you can't directly put the data in in Esimdata.

I sort of need to know what Transdata and Esimdata are to help any further.

Finally if you really want to do the receiving by polling, which is fine then do it properly setup a timer and check for received data from time to time don't sit in a loop and spin your wheels for 100 times.

In vino veritas

The loop is not a poll loop. Just segmenting the data 900000bytes/100 and sending it 100 times, the same way I am receiving it at the client. And the Init function just initialises the CString var. I send/receive the data through Serialization and CTrans is derived from CObject for that purpose. And thats why I am using the EsimData as intermediate. Its declared globally as...
char Esimdata[900000];

void CTrans::Init()
{
m_bClose = FALSE;
m_sData = _T("");
}

Please correct me if I am wrong.

I am still concerned you are bleeding memory did you check the program memory usage isn't continually growing?

Can you use m_sData.Empty(); rather that m_sData = _T(""); I rarely use MFC strings but that line is ringing alarm bells with me.

To smooth the recption down you really need to build a parser on the receive data rather than just sit looping around waiting for the full packet.

Can I get a look at the code for ReceiveData .. as in the call ... ReceiveData(&TransData);

Finally can I suggest you format the data into 3 sections, which was actually suggested to you back in April to make parsing easier and robust.
The packet transmission will be a (i) A fixed signature (ii) a data body size (iii) the body data of the size of (ii)

The parser would be 4 stage .... read signature, read data size, read data, data available (do what you want with it).

enum ReadParseStatus {
readSigState = 0,
readDataSizeState,
readDataBodyState,
readDataAvailState
};

The fix signature needs to be something unlikely to be in data along lines of
const char signature[] = "PACKETSIG%$#";

Your server needs to output matching data packets. Same signature, the size of the data body and then the data body.

If you provide the ReceiveData code I can help with the parser setup, which is a lot better than looping around waiting for data and it's pretty trivial.

In vino veritas

modified 24-May-16 10:49am.

void CMainFrame::ReceiveData(CTrans* pData)
{
/*if(CAsyncSocket::FromHandle(m_pSocket->m_hSocket) == NULL)
{
m_pSocket->Attach(m_pSocket->m_hSocket);
}*/

TRY
{
if( m_pArchiveIn )
pData->Serialize(*m_pArchiveIn);
else
{
pData->m_bClose = TRUE;
m_pArchiveOut->Abort();
}
}
CATCH(CFileException, e)
{
pData->m_bClose = TRUE;
m_pArchiveOut->Abort();
}
END_CATCH

if (pData->m_bClose)
{
delete m_pArchiveIn;
delete m_pArchiveOut;
delete m_pFile;
delete m_pSocket;

m_pArchiveIn = NULL;
m_pArchiveOut = NULL;
m_pFile = NULL;
m_pSocket = NULL;
}
}

Okay 1 polled 4 state parser code .. I commented it so you can follow what its doing. The parse buffer is 4K so you need to poll min rate of 20-30 times a second. You can increase or decrease the parse buffer size and change the poll rate requirements. Just remember your 90K data/ parse buffer size = min poll rate you need.

You can use a timer or hook into the MFC message system to fire of a poll request ... personally I would use a timer. If its just writing the data to a file or something you could just loop the poll call in a thread.

The data body is available in the dataReadyState and you haven't indicated what you do with it so its blank. The parser just cycles an maintains and cleans its own buffers.

enum ReadParseStatus {
	readSigState = 0,
	readDataSizeState,
	readDataBodyState,
	readDataAvailState
};

// This is some unique signature make it what you like
// It should be something unlikely to occur in the data itself
// Make sure the server sends an identical signature and the data size before each packet body
const char signature[] = "PACKETSIG%$#";

// Parse status always starts as read signature
enum ReadParseStatus parseState = readSigState;

// Parse buffer
char parseBuffer[4096];			// The parse buffer itself ... you may adjust this up or down depending on poll rate
int parsePos = 0;				// Position of parse buffer
long bodyDataSize = 0;			// Body data size for current packet
unsigned char* bodyData = NULL; // Body data storage
long bodyDataPos = 0;			// Body data position


// Parses socket receive data
BOOL Poll_Receive_Data (CAsyncSocket sock){

	// Read whatever data is available into the parse buffer up to parse buffer full
	// sock would be m_pSocket in your code
	int iResult = sock.Receive(&parseBuffer[parsePos], sizeof(parseBuffer) - parsePos);
	
	// If return is zero or less there is either no data of something is wrong
	// So return a false so caller knows and can do something
	if (iResult <= 0) return (FALSE);
	
	// Adjust the parse position so space in buffer left can be checked
	parsePos += iResult;

	switch (parseState){
		case readSigState: {	
				// Temp buffer .. its 32 bytes here which must be bigger than signature length
				char tempbuf[32];
				// Hold signature length we will use it a bit in this phase
				int siglen = strlen(signature);
				// Preset sigFound to false
				BOOL sigFound = FALSE;
				// Loop while signature not found and enough data to run signature test
				while ((sigFound == FALSE) && (parsePos > siglen)) {
					// Transfer signature length of data from parseBuffer
					memcpy(tempbuf, &parseBuffer[0], siglen);
					// make sure its asciiz
					tempbuf[siglen] = 0;
					// Look for exact signature match
					if (strcmp(signature, &tempbuf[0])){
						// You found the signature so dump it .. memory overlap needs memmove
						memmove(&parseBuffer[0], &parseBuffer[siglen], parsePos - siglen);
						// adjust parsePos to reflect we removed the signature and dumped it
						parsePos -= siglen;
                        // signature found obviously
                        sigFound = TRUE; 
						// parser moves to next state
						parseState = readDataSizeState;
					} else {
						// So dump first character in parse buffer ... memory overlap so needs memmove
						memmove(&parseBuffer[0], &parseBuffer[1], parsePos - 1);
						// decrement parsePos
						parsePos--;
						// We will loop around now with next data
					}
				}
			}
			break;
		case readDataSizeState: {
				// Temp buffer .. which is size of a long + a character #0
				char tempbuf[sizeof(long)+1];
				// Do we have enough data to recover our data size long
				if (parsePos > sizeof(long)) {
					// Transfer data size long from parseBuffer
					memcpy(tempbuf, &parseBuffer[0], sizeof(long));
					// Make asciiz
					tempbuf[sizeof(long)] = 0;
					// Recover our body data size for this packet
					bodyDataSize = atol(&tempbuf[0]);
					// If we have old body data free the memory because we are on next packet
					// This is a self cleanup to make sure we dont bleed memory
					if (bodyData) free(bodyData);
					// Ok allocate memory to hold the body data, now we know its size
					bodyData = (unsigned char*) malloc(bodyDataSize);
					// Zero the body data position
					bodyDataPos = 0;
					// Done with the body size so dump it from parser .. memory overlap so use memmove
					memmove(&parseBuffer[0], &parseBuffer[sizeof(long)], parsePos - sizeof(long));
					// adjust parsePos to reflect we removed the body size long
					parsePos -= sizeof(long);
					// Now move to read data body parse state
					parseState = readDataBodyState;
				}
			}
			break;
		case readDataBodyState: {
				// We have body data to transfer
				if (parsePos > 0) {
					// This is amount left we need from body data
					long amountLeft = bodyDataSize - bodyDataPos;
					// Calc transfer size, allowing for fact we may have too much
					int transferSize = parsePos;
					if (transferSize > amountLeft) transferSize = amountLeft;
					// Transfer the data from parse buffer
					memcpy(&bodyData[bodyDataPos], &parseBuffer[0], transferSize);
					// Adjust bodyDataPos by transferSize
					bodyDataPos += transferSize;
					// Remove the parse data we just transferred .. memory overlap so use memmove
					memmove(&parseBuffer[0], &parseBuffer[transferSize], parsePos - transferSize);
					// adjust parsePos to reflect we removed the data transferred
					parsePos -= transferSize;
				}
				// Check if we have transferred all the body data so bodyDataPos == bodyDataSize
				if (bodyDataPos == bodyDataSize) {
					// Now move to data available parse state ... your data is ready
					parseState = readDataAvailState;
				}
			}
			break;
		case readDataAvailState: {
			        // Your data is available in bodydata
					// Do what you want with it

			        //.... Use and abuse your bodyData 
					// You havent said what happens to data but its available HERE

					// Set the parser back to the search for signature state for nexy packet
					parseState = readSigState;
			}
			break;
	}

	return (TRUE);	// Parser still working normally return true
}

In vino veritas

modified 26-May-16 5:41am.

manoharbalu wrote:

Is there any specific ways or methods of send/receive huge data continuosly via Csocket.

How to send the big data every interval in a better way.

See here.

"One man's wage rise is another man's price increase." - Harold Wilson

"Fireproof doesn't mean the fire will never come. It means when the fire comes that you will be able to withstand it." - Michael Simmons

"You can easily judge the character of a man by how he treats those who can do nothing for him." - James D. Miles

I rarely suggest a completely different approach, but have you considered ASIO[^](the non-Boost version if you aren't using Boost) and making both the send and receive asynchronous?

i am working on a movie database and i have output from my file that i want to load into my linked list,no problem opening file but when i run this function it enters junk values in the list and only works if i enter all the strings without spaces or seperated by special characters.

i am reading this from the txt file
SHAWSHANK REDEMPTION 120 5 MYSTERY 2009 ENGLISH 3
THE MATRIX 120 5 MYSTERY 2009 ENGLISH 3
THE MATRIX PART1 120 5 MYSTERY 2009 ENGLISH 3
THE MATRIX PART2 120 5 MYSTERY 2009 ENGLISH 3

this is the code for load text from file into a linkedlist(doubly)

C++

void double_llist::loadfromfile(){

    string mname,mgenre,mlanguage;
    int mrelease_year,mamount, mrating,mruntime;
        ifstream fromfile;
        fromfile.open("database.txt");
        while (fromfile >> mname >> mgenre >> mlanguage >> mrelease_year>>mamount>>mrating>>mruntime)
    {
        /* do something with name, var1 etc. */
        cout << mname<<mgenre<<mlanguage<<mrelease_year<<mamount<<mrating<<mruntime<<endl;
    create_list(mname,mgenre,mlanguage,mrelease_year,mamount,mrating,mruntime);
    }
}

the code for doublylinkedlist

C++

void double_llist::create_list(string mname,
    string mgenre,
    string mlanguage,
    int mrelease_year,
    int mamount,
    int mrating,int mruntime)
{

    struct node *s, *temp;
    temp = new(struct node);
    temp->info=id++;
    temp->name = mname;
    temp->genre=mgenre;
    temp->language=mlanguage;
    temp->release_year=mrelease_year;
    temp->amount=mamount;
    temp->rating=mrating;
    temp->runtime=mruntime;
    temp->next = NULL;
    if (start == NULL)
    {
        temp->prev = NULL;
        start = temp;
    }
    else
    {
        s = start;
        while (s->next != NULL)
            s = s->next;
        s->next = temp;
        temp->prev = s;
    }
}

my class and node struct for linkedlist

C++

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<fstream>
/*
 * Node Declaration
 */
using namespace std;
struct node
{
    int info;
    string name;
    string genre;
    string language;
    int release_year;
    int amount;
    int rating;
    int runtime;
    struct node *next;
    struct node *prev;
    static int counter;
}*start;
int id=1;
/*
 Class Declaration
 */
class double_llist
{
    public:

        void create_list(string mname,
    string mgenre,
    string mlanguage,
    int mrelease_year,
    int mamount,
    int mrating,int mruntime);
        void delete_element(int value);
        void search_element(node *head, int value);
        void display_dlist();
        void sorting();
       void update(node *q ,int value);
        int count();
        void reverse();
        void savetofile();
        void loadfromfile();
        void revertsort();
        double_llist()
        {
            start = NULL;

        }
};

A couple of minutes with the debugger would have shown you that you cannot enter text like that and expect the system to realise that the film title comprises more than one word. Stream input breaks fields up at white space so in your first case you will have something like:

mname = SHAWSHANK
mgenre = REDEMPTION
mlanguage = 120
mrelease_year = 5
mamount = MYSTERY - which is not an integer
mrating = 2009
mruntime = ENGLISH - also not an integer

the final 3 will now go into the title next time round the loop.

yes i know that's why i am asking a solution for that.

You need to split the lines manually so that you can separate the title from the other fields. You could just read the entire line, tokenise it into an array, and then work backwards field by field. Whatever is left at the beginning of the array can be recombined into a single string which is the title.

The easy solution is to override the read and write methods in your own stream extension.

It is the "standard", "usual" and "prefered" way to fix behaviour of classes or objects with methods and functions that aren't exactly as you desire.

Can I go so far as to suggest MovieNameStream as a possible title for the extension.

In vino veritas

Farhan_Karim wrote:
works if...all the strings...seperated by special characters.

Is that not a possibility?

"One man's wage rise is another man's price increase." - Harold Wilson

"Fireproof doesn't mean the fire will never come. It means when the fire comes that you will be able to withstand it." - Michael Simmons

"You can easily judge the character of a man by how he treats those who can do nothing for him." - James D. Miles

I have Dev C++ on my system to practice writing C++ code from my C++ Programming for the Absolute Beginner book. So far, the constant repetition and copying have improved my muscle memory. Then, recently, I just noticed that this application could autocomplete my line.

My biggest worry is that this autocomplete thing would make me fail the Computer Science placement exam. I really want to take the placement exam, so then I can get tested into the software development class and skip the introductory CS classes. On the school's website, it says that the placement exam takes place on paper and pencil, so that implies I should know how to write everything down to smallest detail and get it accurate enough so the algorithms would run correctly.

Should beginners use Autocomplete? Maybe it's good practice for a beginner to write code on paper and then transfer the code onto the computer?

Member KL wrote:
Maybe it's good practice for a beginner to write code on paper and then transfer the code onto the computer?

That's a good idea for anyone, not just beginners.

"One man's wage rise is another man's price increase." - Harold Wilson

"Fireproof doesn't mean the fire will never come. It means when the fire comes that you will be able to withstand it." - Michael Simmons

"You can easily judge the character of a man by how he treats those who can do nothing for him." - James D. Miles

That sounds completely impractical... perhaps good for a learner but you'd never get anything done if you were writing things on paper first before transposing the same exact thing onto real code.

I guess you never had the joy of writing your code in pencil, on fixed width coding sheets. These were then sent to the data prep department to be punched onto Hollerith (80 column) cards, before being submitted to the computer room for compilation. And then you had to wait a couple of hours for the results which showed you had missed a comma on the second line. Mad | :mad:

Luckily, no... that would be painful!

I have however worked on FPGAs, that's a similarly slow process of building/routing. You're not writing things on paper but you're definitely waiting for a really long time for synthesis and routing. I was working on these guys a few years ago now but our builds would take about a couple of hours too. You'd be really disappointed when things didn't quite work or you forgot some debug traces. Dead | X|

It depends how much work your auto-complete does for you. As a learner, you should avoid auto-complete that makes classes and sets of methods for you. If however, all it's doing is completing a word, well... you're learning to program, not to spell... so that little bit of help won't undo what you're learning.

At the end of the day what will make you a better programmer will ultimately be how many hours you spend programming. Practice, practice, practice....

Good luck! Cool | :cool:

I don't see any problem using Autocomplete, it is just a typing aid. As long as you don't use Autocomplete to avoid learning the syntax.

I never write my programs on paper before typing. I only resort to paper to draw diagrams when the current problem is complicated. I do this because I use a very good analyze method.

I recommend Dijkstra Top-Down method it is a good start.
https://en.wikipedia.org/wiki/Top-down_and_bottom-up_design[^]
https://en.wikipedia.org/wiki/Structured_programming[^]
https://en.wikipedia.org/wiki/Edsger_W._Dijkstra[^]
https://www.cs.utexas.edu/users/EWD/ewd03xx/EWD316.PDF[^]

Patrice

“Everything should be made as simple as possible, but no simpler.” Albert Einstein

Definitely use a whiteboard or paper for architecting a complicated system (or a software tool like Visio). Last thing you want to do is spend a bunch of time writing software that doesn't really make sense in the grand scale of things (architecture-wise).

Thumbs Up | :thumbsup:

Albert Holguin wrote:
Definitely use a whiteboard or paper for architecting a complicated system (or a software tool like Visio).

That is what I do when I say

PPolymorphe Wrote:
I only resort to paper to draw diagrams when the current problem is complicated.

Albert Holguin wrote:
Last thing you want to do is spend a bunch of time writing software that doesn't really make sense in the grand scale of things (architecture-wise).

Can only agree.

Patrice

“Everything should be made as simple as possible, but no simpler.” Albert Einstein

ppolymorphe wrote:
That is what I do when I say

PPolymorphe Wrote:
I only resort to paper to draw diagrams when the current problem is complicated.

I was only agreeing/elaborating...

Ok then. English is not my primary language and sometimes, I miss things Blush | :O

Patrice

“Everything should be made as simple as possible, but no simpler.” Albert Einstein

Academic point of view:
You should avoid using autocomplete or similar helpers so that you can have better hands-on.

Professional point of view:
You should not miss any helpers (autocomplete, automation etc.) so that you become more productive.

Best wishes Smile | :)