public partial class Form3 : MyNameSpace.Form2

byte[] buffer = (byte[])cmd1.ExecuteScalar();

    int fileds[2];

        int reading[num_cmds];

        int writing[num_cmds];



        int p;

        for(p=0; p < num_cmds; p++)

        {

                reading[p] = -1;

                writing[p] = -1;

        }



        int j;

        for(j=0; j < num_cmds-1; j++)    //Create pipes for commands

        {

                int fileds[2];

                pipe(fileds);

                reading[j+1] = fileds[0];

                writing[j] = fileds[1];

        }



        int i = 0;

        for(i = 0; i < num_cmds;i++)

        {                       

                cmd_args = parse_cmd(cmds[i],output_file,input_file,&run_bg); //Get command and args



                pid_t childpid;

                int status;

                childpid=fork();



                if (childpid >= 0) 

                {

                        if (childpid == 0) 

                        {                               

                                if(writing[i] != -1)

                                {

                                        dup2(writing[i],1);

                                        close(writing[i]);

                                }



                                if(reading[i] != -1)

                                {

                                        dup2(reading[i],0);

                                        close(reading[i]);

                                }



                                int h;

                                for(h = 0; h < num_cmds; h++)

                                {

                                        close(writing[h]);

                                        close(reading[h]);

                                }



                                if(execvp(cmd_args[0],cmd_args) == -1) 

                                {

                                        perror("Problem with command");

                                        exit(0);

                                }

                        }

                        else 

                        {

                                wait(&status);

                                int m;

                                for(m = 0; m < num_cmds; m++)

                                {

                                        if( writing[m] != -1) close(writing[m]);

                                        if( reading[m] != -1) close(reading[m]);

                                }

                        }

                }

                else 

                {

                         perror("fork"); 

                         continue;

                }





                input_file[0] = 0;

                output_file[0] = 0;

                run_bg = 0;

        }



}

 //        ===================

        #include "stdafx.h"

        #include <iostream>

        #include <iomanip>

//        ===================



//        ===================

//        function prototypes

//        ===================

        int vowel(int);

//        ===================



//        ==========

//        Name Space

//        ===================

        using namespace std;

//        ====================

        

//        ===========

        int main( )

        {

//        =====================

//        variable declarations

//        ==================

        char enterLetter;

        char userResponse;

        char userInput;

        int    vowelCounter;

//        ============



//        ============

//        input letter

//        ===================

        while(enterLetter){

        cout << "Please enter a string of characters " << endl;

        cout << "and I will tell you how many vowels you entered. "  << endl;

        cin >> userInput;

        cout << endl;

//        =================



//        =======

//        analyze 

//        ===========================

        vowelCounter = vowel(userInput);

        if(vowelCounter > 0) 

        cout << "You have entered " << vowelCounter

                << " vowels." << endl;

        else 

        cout << "You did not enter any vowels in this   string of characters." << endl;

//        =====================





        cout << "Go again? (y/n)?" << endl;

        cin >> userResponse;

        cout << endl;

        

        if(userResponse == 'n')

        enterLetter = false;

                } 



        return 0;

        }//function main





//        ================

//        function vowelCount

//        ==========================

        int vowel (char userInput)

        {

         int vowelcounter = 0, i;

         for(i=0; i < userInput.length(); i++)

           switch (userInput[i])

          {

                case 'a':

            case 'A':

            case 'e':

            case 'E':

                case 'i':

            case 'I':

            case 'o':

                case 'O':

                case 'u':

                case 'U':

              vowelcounter++;        

                  break;

          }

          return vowelcounter;

        }

//        function vowelCount

DbDataReader

        public DataTable SelectAll(string tableName, DbConnection conn)

        {

            DataTable dt = new DataTable();



            try

            {

                string query = "SELECT * FROM " + tableName;



                conn.Open();



                using (DbCommand cmd = GetDbCommand(query, conn))

                {

                    using (DbDataReader dr = cmd.ExecuteReader())

                    {

                        dt.Load(dr);

                    }

                }

            }

            catch (DbException ex)

            {

                Console.WriteLine("Exception: {0}\r\n   Stack Trace: {1}", ex.Message, ex.StackTrace);

                System.Diagnostics.Debugger.Break();

            }

            finally

            {

                conn.Close();

            }



            return dt;

        }

//***************************************************************************

//This program asks a series of arithmetic problems

//and reports the user's performance

//***************************************************************************

#include<iostream>

#include<iomanip>

#include<cstdlib>

#include<ctime>

using namespace std;



void doOneSet();

void doOneProblem();

void generateOperands(int &num1, int &num2);

void calcCorrectAnswer(int &result, int &userNum1);

void checkAnswer(int result, int userNum1);





int main()

{

    srand(time(0));

    doOneSet();





system("pause");

return 0;

}

//***************************************************************************

void doOneSet()

{

        

        doOneProblem();

        doOneProblem();

        doOneProblem();

        doOneProblem();

        doOneProblem();

}

//***************************************************************************

void doOneProblem()

{

        int num1, num2, result, userNum1;

        

        generateOperands(num1, num2);

        calcCorrectAnswer(result, userNum1);

        checkAnswer(result, userNum1);

        

}

//***************************************************************************

void generateOperands(int &num1, int &num2)

{

        

        

    num1=rand()%101;

    num2=rand()%101;

}

//***************************************************************************



void calcCorrectAnswer(int &result, int &userNum1)

{

        int num1, num2;

        

                cout<<num1<<"+"<<num2<<"=";                   //To make arithmetic problem

                  cin>>userNum1;

                  result=num1+num2;



}

//**************************************************************************

void checkAnswer(int result, int userNum1)

{

        

                        if(userNum1==result)

                        {

                         cout<<"correct"<<endl;

                        }

                        else

                        {

                         cout<<"incorrect"<<endl;

                        }

}

/**

 * AWT Sample application

 *

 * @author 

 * @version 1.00 09/11/04

 */

public class scramble {

    public static void main(String[] args)

    {

            String s = "these programs encrypt";

            String e = "";

            

                          String tmp = "";

                  int x = 1;

                  int d = 5;

//                  block = s.substring(d);

                          for (int i = 0; i < s.length(); i++)

                          {

                                  if (s.charAt(i) != ' ')

                                  {

                                          tmp += s.charAt(i);

                                          x++;

                                  }

                                  if (x>d)

                                  {

                                          tmp += ' ';

                                          x = 1;

                                  }

                          

                          

                          

                  

                          }

                          System.out.println(tmp);

                          }

//                           block1 = s.substring("d");

                  //        for(int i = 0; i<block1.length; i++)

                  //        {

                  //                block1.indexOf("t");

                          //}

                          }

#include <semaphore.h>

#include <pthread.h>

#include <stdlib.h>

#include <stdio.h>

#include <unistd.h>

// I'm using g++ to compile this program in Ubuntu 9.04. I use the command ./a.out to run it.



/*

The program simulates many producers and consumers.

Producers are many and put products in a joint stack. Consumers are also many and take from this same stack.



Only the product number goes into the stack, nothing else.



Each producer makes a product number by random from 0..PRODUCTS-1 and puts into the stack. It also raises 



the appropriate element in array "production" by 1.

It also raises the production_total with 1.



Each consumer looks at the number at the top of each stack.

It raises the counter by 1 over what has been 



"consumed" by that production number by raising the element in the array "consumption". It also raises 



consumption_total by 1.



After all the threads have finished all numbers must match.

The array production must look like the array 



consumption and production_total must look like consumption_total.



The stack must start and end in 0.



So that can happen I need to synchronize producers and consumers with semaphors and mutex so they will not 



interrupt each other. How can I make the threads end? Where should I put the semaphors and mutex?

*/



#define PRODUCERS 20

#define CONSUMERS 20

#define PRODUCTS 25

#define STACKMAX 100



// Producers produce products with a product number between 0..PRODUCTS



// array production og consumption store numbers for production and consumption

// for each product.

int production[PRODUCTS];

int production_total;

int consumption[PRODUCTS];

int consumption_total;



int stacksize;  // stack can be 0..STACKSIZE-1, I need to use semaphore to watch out for highs and lows...

int stack[STACKMAX];



// This is how I learnt how to create a semaphore

sem_t semaphore;



//This is how a semaphore is usually used:

//sem_wait(&semaphore);

//sem_post(&semaphore);





//This is how I learnt how to create a mutex - could need more

pthread_mutex_t mutex;

//This is how they're suppoes to be used

//pthread_mutex_lock(&mutex);

//pthread_mutex_unlock(&mutex);



#define True 1

#define False 0



// If quitting = True then we're stopping and all threads should exit

int quitting;





void* producer(void *arg)

{

    int product_number;



    printf("I'm a producer\n");



    return NULL;  // This needs to be removed so the code will run



    // I need to change this code!  Here I need at least one semaphore and probably one mutex.

    // The 



if.then.else used here is not the most suitable solution. 

    while(!quitting)

    {

         if(stacksize<STACKMAX)

         {

              product_number=rand()%PRODUCTS;  // Some number on between 0..PRODUCTS

              // Put on stack

              stack[stacksize++]=product_number;



              // and record it..

              production[product_number]++;

              production_total++;

         }

         else

         {

              printf("The stack is full!\n");

         }

    }

    return NULL;

}



void* consumer(void *arg)

{

    int product_number;



    printf("I'm a consumer!\n");



    return NULL;  // This return should delete



    // I need to change this code!  Here I need at least one semaphore and probably one mutex.

    // The 



if.then.else used here is not the most suitable solution. 



    while(!quitting)

    {

         if(stacksize>0)

         {

              product_number=stack[--stacksize];

              consumption[product_number]++;

              consumption_total++;

         }

         else

         {

              printf("The stack is empty!\n");

         }



    }

    return NULL;

}





int main(int argc, char **argv)

{

    pthread_t consumer_threads[CONSUMERS];

    pthread_t producer_threads[PRODUCERS];





    // Initialize the semaphore with a value of 1.

    // Note the second argument: passing zero denotes

    // that the semaphore is shared between threads (and

    // not processes).

    if(sem_init(&semaphore, 0, 1))

    {

        printf("Could not initialize a semaphore\n");

        return -1;

    }



    // Initialize the mutex

    if(pthread_mutex_init(&mutex, NULL))

    {

        printf("Unable to initialize a mutex\n");

        return -1;

    }



    // Null random generator

    srand(0);



    // Null all counters

    stacksize=0;

    consumption_total=0;

    production_total=0;

    for(int i=0;i<PRODUCTS;i++)

    {

         consumption[i]=0;

         production[i]=0;

    }



    // Consumers can look at this global variable to see if producers have stopped producing          // and it's 



safe to quit

    quitting=False;



    // Print initial values

    printf("stacksize (should be 0) = %i\n",stacksize);

    printf("production_total = %i\n",production_total);

    printf("consumption_total = %i (needs to match production)\n",consumption_total);



    printf("Production array broken down:\n");

    for(int i=0;i<PRODUCTS;i++)

    {

         printf("%i ",production[i]);

    }

    printf("\n");



    printf("Consumption array broken down (needs to match production array):\n");

    for(int i=0;i<PRODUCTS;i++)

    {

         printf("%i ",consumption[i]);

    }

    printf("\n");





    // Start the producer

    

    for(int i = 0; i < PRODUCERS; ++i)

    {

        if(pthread_create(&producer_threads[i], NULL, &producer, NULL))

        {

            printf("Could not create thread %d\n", i);

            return -1;

        }

    }



    // Start the consumer



    int thread_count=0;



    for(int i = 0; i < CONSUMERS; ++i)

    {

        if(pthread_create(&consumer_threads[i], NULL, &consumer, NULL))

        {

            printf("Could not create thread %d\n", i);

            return -1;

        }

    }



    // The main program sleeps for a while

    // then puts the global variable qutting = True , by that all consumers and producers 

    //should stop 



producing.

    sleep(3);

    quitting=True; 

    printf("Now the main program wants to quit...\n");





    for(int i = 0; i < CONSUMERS; ++i)

    {

        if(pthread_join(consumer_threads[i], NULL))

        {

            printf("Could not join thread %d\n", i);

            return -1;

        }

    }



    for(int i = 0; i < PRODUCERS; ++i)

    {

        if(pthread_join(producer_threads[i], NULL))

        {

            printf("Could not join thread %d\n", i);

            return -1;

        }

    }



    printf("All threads are dead\n");



    sem_destroy(&semaphore);

    pthread_mutex_destroy(&mutex);



    printf("All over.. now everything should match\n");

    printf("stacksize (should be 0) = %i\n",stacksize);

    printf("production_total = %i\n",production_total);

    printf("consumption_total = %i (needs to match production)\n",consumption_total);



    printf("Production array broken down:\n");

    for(int i=0;i<PRODUCTS;i++)

    {

         printf("%i ",production[i]);

    }

    printf("\n");



    printf("Consumption array broken down (needs to match production array):\n");

    for(int i=0;i<PRODUCTS;i++)

    {

         printf("%i ",consumption[i]);

    }

    printf("\n");



    return 0;

}

Attached Files

project_1.cpp (7.1 KB)

public class Server {

    public static void main(String[] args) throws IOException {

        ServerSocket serverSocket = null;

        boolean listening = true;

                new StdinReaderThread();



        try {

            serverSocket = new ServerSocket(4444);

        } catch (IOException e) {

            System.err.println("Could not create socket");

            System.exit(-1);

        }



        while (listening){

                new ServerThread(serverSocket.accept()).start();

                }

        serverSocket.close();

    }

}

public class StdinReaderThread implements Runnable{

                BufferedReader stdin;



                public StdinReaderThread(){

                        Thread subpr = new Thread(this,"x");

                        stdin = new BufferedReader( new InputStreamReader(System.in));

                        subpr.start();

                }

                public void run(){

                        while (true){

                           try{

                              String stdinline = stdin.readLine();

                              if( stdinline.startsWith("q")){

                                    System.out.println("end");

                               }

                                  else if( stdinline.startsWith("m"))

                                        System.out.println("send message");

                                  else if( stdinline.startsWith("l"))

                                        System.out.println("send login");

                                  else if( stdinline.startsWith("u"))

                                        System.out.println("list users");

                            } catch (Exception e){}

                    }

        }

}

#include <cstdio>

#include <cmath>

#include <iostream> 

#include <cstdlib>

 

using namespace std;



int main()

{

cout << "\t\tNetwork";



//declaring security

int info;

int security = 0;



//getting the Username

string szUsername;

cout <<"\nUsername: ";

cin >> szUsername;



//getting the password

string szPassword;

cout <<"\npassword: " << endl;

cin >> szPassword;



//action for successful loggin of the user "kornelia"

if (szUsername == "kornelia" && szPassword == "lelewel8")

{

cout << "\nHallo Kornelia, dein login war erfolgreich";

security = 5;

}

// action for successful loggin of the user "eduard"

if (szUsername == "eduard" && szPassword == "afkem2009")

{

cout << "\nHallo Eduard, du hast dich erfolgreich eingeloggt";

security = 5;

}

//action for successful loggin of the user "gast"

if (szUsername == "gast" || szPassword == "gast")

{

cout << "\nHerzlich willkommen Gast";

security = 1;

}

//action for wrong name or password

if (!security)

   cout << "Ihr loggin ist fehlgeschlagen\n" << endl;



//action for security clearing = 5

if (security == 5)

{

// welcome and basic menu for selecting infos

cout << "Sie haben Sicherheitsstufe 5 (777 Rechte)" << endl;

cout << "Welche Informationen wollen sie erhalten?\n1: Computerpassword Kornelia";

cout << "\n2: Computerpassword Eduard\n3: Routerpassword";

cin << info;

// cout the infos

if (info == 1)

{

         cout << "Der Computer besitzt kein Password";

}

if (info == 2)

{

         cout << "Das Computerpassword von Eduard lautet: afkem2009";

}

if (info == 3)

{

         cout << "Benutzername: admin\nPassword: lelewel8";

}

}

// end

system("PAUSE");

return 0;

}

#include <fstream>

#include <iostream>

#include <iomanip>

#include <cstdlib>

using namespace std;



/** [ I get the "unknown size" error on all of these b/c I don't know how to assign them ] */



int studentID[];

int creditHours[];

double gpa[];





int main()

{



int studentID[]; 

int creditHours[]; 

int gpa[];

ifstream students; 

ofstream freshman, sophomores, juniors, seniors; 





ifstream in_stream;

in_stream.open("students.txt");



if (in_stream.fail())

{

cout<< "Input file opening failed.\n";

exit(1);

}



ofstream out_stream;

out_stream.open("freshmen.txt");

out_stream.open("sophomores.txt");

out_stream.open("juniors.txt");

out_stream.open("seniors.txt");

out_stream.open("hoursError.txt");

out_stream.open("averageError.txt");

out_stream.open("identError.txt");



if (out_stream.fail())

{

cout<< "Output file opening failed.\n";

exit(1);

}



out_stream.setf(ios::fixed);

out_stream.setf(ios::showpoint);

out_stream.precision(2);



while (!students.eof())

{



void getInput(ifstream students, int &studentID, int &creditHours, int &gpa);



}





/** [ error C2446: '<' : no conversion from 'int *' to 'int' There is no context in which this conversion is possible ] & [ error C2040: '<' : 'int' differs in levels of indirection from 'int []' ] */



for (int i=0; i < studentID; i++)

out_stream << studentID[i] << creditHours[i] << gpa[i] << endl;





in_stream.close();

out_stream.close();

}







/** [ error C4430: missing type specifier - int assumed. Note: C++ does not support default-int ]*/



getInput(ifstream students, int &studentID, int &creditHours, int &gpa); 



// [ error C2447: '{' : missing function header (old-style formal list?) ]

{ 

    int i = 0; 

        while(!students.eof()) 

        { 

       students >> &studentID[i] >> &creditHours[i] >> &gpa[i]; 

       cout << studentID[i] << creditHours[i] << gpa[i] << endl; 

           i++; 

        } 

return;



}

           BOZOS_CODE SEGMENT    ;The "logical" segment is named BOZOS_CODE

             ASSUME CS:BOZOS_CODE   ;The "assume" statement tells the assembler

                                    ; that BOZOS_CODE is a code segment (CS)

             ORG 100h            ;In case we decide to convert the program

                                 ; to a COM file (makes 256 "empty" locations)



           START: jmp begin      ;Since this is a code segment the first non-

                                 ; directive item must be an instruction. We

                                 ; jump around our data area



          

          num_of_bytes EQU 3

          first_num db num_of_bytes dup (0), '$'

          second_num db num_of_bytes dup (0), '$'

          the_sum db num_of_bytes + 1 dup (0), '$'

          message_1 db 'Enter the first multi-digit number (up to 12 digits in length) followed by a'

                    db '"+" symbol then enter a second multi-digit number (up to 12 digits in '

                    db        'length) followed by a "=" symbol  $'

                  

                          



          key_stroke db 'x$'

          operand db 'x$'







GET_NUM:         mov ah, 00h    ;Read keyboard function

                 int 16h        ;Call BIOS (return occurs when key is pressed)

                                 ;AL now contains the ASCII code of key pressed

                 

                 mov key_stroke, al



                 mov ah, 09h                ;Display string function

                 mov dx, offset key_stroke  ;Pass the starting address of string

                 int 21h                    ;Call DOS

                 

                 mov al, key_stroke



                 cmp al, cl   

                 jne continue

                 ret                ;return



continue:           and al, 0fh



                 mov [BX], al

                 

                 inc BX

                

                 cmp [bx], ch



                 jbe get_num

                 

                 mov operand, cl

                

                 mov ah, 09h                  ;Display string function

                 mov dx, offset operand       ;Pass the starting address of string



                 int 21h          ;Call DOS

                 ret                  ;return



REV_NUM:          mov cl, [bx]



                 mov ch, [di]



                 mov [di], cl



                 mov [bx], ch



                 dec BX

                 inc di

                 

                 cmp di, bx

                                   

                 jae rev_num

                 ret

        

           

begin:                   mov ax, cs     

                  mov ds, ax     



                  mov cl, 0      

                  

                  mov ah, 06h    ;Scroll-up window function

                  mov al, 0      ; Clear entire window

                  mov bh, 1ch    ; Display "attribute byte" for cleared area

                                 ;  Blue background/Red characters

                                 ;  Bit definitions: Blink|Background R,G,B|

                                 ;                   Intensity|Character R,G,B

                  mov ch, 0      ; Y = 0     (Corner coordinates of window

                  mov cl, 0      ; X = 0      to clear)

                  mov dh, 24     ; Y = 24        

                  mov dl, 85     ; X = 79        

                  int 10h        ;Call BIOS



                                                   

                 mov ah, 02h    ;Set cursor position function

                 mov bh, 0      ; Display page 0

                 mov dh, 0      ; Y position  25 rows    (Y: 0 -> 24)

                 mov dl, 0      ; X position  80 columns (X: 0 -> 79)

                 int 10h        ;Call BIOS



                  

                 mov ah, 09h              ;Display string function

                 mov dx, offset message_1 ;Pass the starting offset of the

                                           ; string to be displayed

                                           ; (the string to be displayed starts 

                                           ;  at the label message (in the data

                                           ;  area) and ends with a '$')

                                           ;Note: DS must point to the beginning

                                           ;      of the segment containing the

                                           ;      string to be displayed, e.g.,

                                           ;      mov ax, cs  (usually done at

                                           ;      mov ds, ax   the beginning of

                                           ;                   the program)

                                           ;Note: This display procedure updates

                                           ;      the cursor position as each

                                           ;      character is displayed

                 int 21h                  ;Call DOS

                 

                 mov bx, offset first_num

                 mov cl, '+'

                 mov ch, num_of_bytes

                 

                 call get_num

                

                 mov bx, offset second_num

                 mov cl, '='

                 mov ch, num_of_bytes       ;do i need to do this again?

                

                 call get_num

                

                 mov di, offset first_num

                 

                 call rev_num

                

                 mov di, offset second_num

                 

                 call rev_num



                 mov BX, 0   ;Index set to zero now

                 mov ah, 0   ;ah now used for carry, and is set to zero



adder:           mov al, first_num[BX]

                 add al, second_num[BX]

                 add al, ah

                 

                 cmp al, 9

                 jbe no_carry

                 mov ah, 1 

                 sub al, 10

                 jmp make_ascii



no_carry:          mov ah, 0

                



make_ascii:         or al, 30h

                   

                 mov the_sum[BX], al

                 inc BX



                 cmp BX, num_of_bytes 

                 je fix_carry                ; if array is full jump to fix carry character

                    jmp adder

                 

fix_carry:         or ah, 30h

                

                 mov the_sum[BX], ah

                           

                 mov bx, num_of_bytes - 1

                 mov di, offset the_sum

                 

                 call rev_num 

                

                ;to display sum

                  

display:          mov ah, 09h                ;Display string function

                 mov dx, offset the_sum     ;Pass the starting address of string

                 int 21h                    ;Call DOS



                 ;To exit to DOS



exit:             mov ah, 4ch    ;Exit to DOS function

                  mov al, 0      ;ERRORLEVEL = 0

                  int 21h        ;Call DOS







           BOZOS_CODE ENDS

           END START           ;You MUST have a carriage return after START

 sed 's/(word)/(with-word)'/ file name

vi showme.sh(script name)



echo "type the file to be search"

 read fname

if ls -lart | $fname

then 

echo " File exist"

else echo " File fail"

------(uptil here it run fine)

echo " type the file to be replace/or substituted"

read tname

#ifndef STANDINGS_H

#define STANDINGS_H



#include <iostream>

#include <list>

#include <fstream>

#include <iomanip>



using namespace std;



#define NAMELENGTH 20



struct Records

{

        int totalWin;

        int totalLose;

        double winPercentage;

        double gamesBehind;

        int streakWin;

        int streakLose;

        int streakLength;

        int homeWin;

        int homeLose;

        int awayWin;

        int awayLose;

        int interWin;

        int interLose;

        int division;

        char teamName[NAMELENGTH];

        char streakType;



};





class Standings

{

private:

        list<Records> recordsList;

        friend class Team;

public:

        Standings();

        ~Standings(){};

        void loadList();

        void saveList();

        void printStandings();

        bool compareForSort (Records&, Records&);

        

};



#endif



#include "standings.h"



Standings::Standings()

{



}        





void Standings::loadList(){

        //Create a variable of ifstream type names loadFile

        ifstream loadFile;                     

        //Open standings txt file

        loadFile.open("standings.txt");                 

        //Temporary object of struct type Record

        Records r;





        //Loop to take from file put into class 

        //and than put class into list

        while(!loadFile.eof()){

                loadFile >> r.teamName

                        >> r.totalWin

                        >> r.totalLose

                        >> r.winPercentage

                        >> r.gamesBehind

                        >> r.streakWin

                        >> r.streakLose

                        >> r.streakType

                        >> r.streakLength

                        >> r.homeWin

                        >> r.homeLose

                        >> r.awayWin

                        >> r.awayLose

                        >> r.interWin

                        >> r.interLose

                        >> r.division;



                //Checks to make sure its not the end of file.

                //If its not the end of the file it inserts 

                //the node at the end of the list

                if(!loadFile.eof())

                        recordsList.push_back(r);

        }

         //closing the text file

        loadFile.close(); 

}



void Standings::saveList()

{

        //Sorts the List before saving to txt

        recordsList.sort(compareForSort);

        //Create a variable of ofstream type names saveFile

        ofstream saveFile;                    

        //Open standings txt file

        saveFile.open("standings.txt");        

        //Create an iterator to keep place of the nodes saved

        list<Records>::iterator i;



        //Loop through each node and save each member to that node

        for ( i=recordsList.begin(); i != recordsList.end(); ++i ) {

                saveFile << right << setw(13) << i->teamName << setw(4) << i->totalWin 

                << setw(4) << i->totalLose << setw(7) << setprecision(3) << i->winPercentage 

                << setw(6) << i->gamesBehind << setw(2) << i->streakWin 

                << setw(2) << i->streakLose  << setw(2) << i->streakType 

                << setw(2) << i->streakLength  << setw(3)<< i->homeWin 

                << setw(3) << i->homeLose  << setw(3) << i->awayWin 

                << setw(3) << i->awayLose  << setw(3)<< i->interWin 

                << setw(3) << i->interLose  << setw(2) << i->division 

                << endl;

        }

//Flush and Close txt file

        saveFile.flush();

        saveFile.close();



}



void Standings::printStandings()

{

        list<Records>::iterator i;



        //Looping through each node and printing each variable of each node

        for ( i=recordsList.begin(); i != recordsList.end(); ++i ) 

        {

                cout  << right << setw(13) << i->teamName << setw(4) << i->totalWin 

                        << setw(4) << i->totalLose << right << setw(7) << i->winPercentage 

                        << right << setw(6) << i->gamesBehind << right << setw(2) << i->streakWin 

                        << right << setw(2) << i->streakLose << right << setw(2) << i->streakType 

                        << right << setw(2) << i->streakLength <<right << setw(3)<< i->homeWin 

                        << right << setw(3) << i->homeLose << right << setw(3) << i->awayWin 

                        << right << setw(3) << i->awayLose << right << setw(3)<< i->interWin 

                        << right << setw(3) << i->interLose << right << setw(2) << i->division 

                        << endl;

        }

}





bool Standings::compareForSort(Records& node1, Records& node2)

{

        list<Records>::iterator i;

        for ( i=recordsList.begin(); i != recordsList.end(); ++i ) {

                if((node1.totalWin > node2.totalWin) && (node1.winPercentage > node2.winPercentage) && (node1.division < node2.division))

                        return true;

                else 

                return false;

        

        }



}

def create_dict(f):

    f = open("something.txt")

    d = {}

    for line in f:

        columns = line.split(",")

        letters = columns[0]

        numbers = columns[2]

// Dataprep.cpp : Defines the entry point for the console application



#include "stdafx.h"

#include <vector>

#include <fstream>

#include <iostream>

#include <string> 

#include <sstream>

#include <math.h>

#include <cstring>

using namespace std;

int NumLines;

void Error (int);

int Open_Price_Data_File (char* filename);

struct Bar* Define_Array (const char*);

void Parse_Output_To_File (struct Bar* dataArray, const char*);

void Date_Verification ();

void ExitScreen ();







//Structure Declaration and Array Initialization 

       struct Bar

       {

               string date;              // date

               double open;              // opening price

               double high;              // high price

               double low;               // low price 

               double close;             // closing price



       };



           struct Bar *bararray;



//Error catching function

void Error(int errorcode) 

{

 if(errorcode == 1) {

     cout << "Error in opening file...";

 }

 else cout << "OK";

}





//Function to open price data file

 int Open_Price_Data_File (char* filename)

 {

   cout << "Enter filename in the following  format c: backslash filename.csv: "; 

               cin >> filename;

               ifstream infile;

               cout << "Reading from the price data file" << endl;

               infile.open(filename); 

        if(!infile.is_open()){

           Error (1);

                }

                  else return 0;

        infile.close();

                 return 1;

 }



                           



// Function to count number of lines in file & define the array of structures accordingly

struct Bar* Define_Array (const char* filename)

{

                                                     

        ifstream infile;                          

        infile.open(filename); 

               if(!infile.is_open())

               {

                 Error (1);

               }

         else

                {

               string line;

               while(getline(infile, line))

               NumLines++;

               cout << "This is the total number of lines in the source file: ";

               cout << NumLines << endl; 

               Bar *bararray = NULL;

               bararray = new Bar[NumLines];

               infile.close();

               return bararray;

                 }

                         

                



}

                                 



             



// String Parsing to Skip Commas

 void Parse_Output_To_File (struct Bar *dataArray, char* filename)

 {

        ofstream outfile;

                outfile.open ("c:\\Outputfile.txt");

                if (!outfile.is_open())

               {

                       cout << "Error in opening file for writing!";

               }

               else return;         

         

             ifstream redo;

             redo.open(filename);

             int i = 0;

                               

               while (!redo.fail())                            

       {        

               int j = 0;    

               string data, token;

               getline(redo, data);

               istringstream isstream (data);

               while (getline(isstream,token,',')) 

                       {

                         outfile << token << " ";

                                 if(j == 0) {

                                       dataArray[i].date = token;

                                       j++;

                                   continue;

                       }



                               if(j == 1) {

                                       dataArray[i].open = atof( token.c_str());

                                       j++;

                                   continue;

                       }



                               if(j == 2) {

                                       dataArray[i].high = atof( token.c_str());

                                       j++;

                                       continue; 

                       }



                               if(j == 3) {

                                     dataArray[i].low = atof( token.c_str());

                                       j++;

                               continue;

                       }



                              if(j == 4) {

                                      dataArray[i].close = atof(token.c_str ());

                                      j++;

                                 continue;                     

                                   }

                                                        

                                                        

                           }        



                                

         i++                                                outfile << endl;

                           }

                redo.close()                                        outfile.close(); 

                                                

 }



// Date Verification Function



void Date_Verification (struct Bar *dataArray)

{

    cout << "This is the first date in the database: ";

    cout << dataArray[0].date << endl;

    cout << "This is the last date in the database:  ";

    cout << dataArray[NumLines - 1].date << endl;

    cout << "Enter the start date for the analysis in the mm/dd/yyyy format: ";

    string startdate;

    cin >> startdate;

    cout << "The startdate you entered is: " << startdate << endl;

                                                        

  int i;                            

   for (i = 0; i <= NumLines -1;)

   {

                                                                if (!strcmp(startdate.c_str(), dataArray[i].date.c_str()) == 0)        

                                                                {

                                                                        i++;                                                        if (i == NumLines -1)

                                                                        cout << "Incorrect start date " << endl;

                                                                }

                                                                else

                                                                {

                                                                        cout << "Start date exists in the database" << endl;

                                                                        break;

                                                                }

                                                        }



cout << "Enter the end date for the analysis in the mm/dd/yyyy format: ";

       string enddate;

       cin >> enddate;

       cout << "The enddate you entered is: " << enddate << endl;

       for (i = 0; i <= NumLines -1;)

 {

                                                                if (!strcmp(enddate.c_str(), dataArray[i].date.c_str()) == 0)        

                                                                        {

                                                                                i++;

                                                                                if (i == NumLines -1)

                                                                        out << "Incorrect end date" << endl;

                                                                        }

                                                                        else

                                                                        {

                                                                cout << "End date exists in the database" << endl;

                                                                                break;

                                                                        }

                

 }



}

                                                        







// User Prompt to Retain Command Window 

void ExitScreen ()

 {

               char ch;

               cout << "Please press Q or q to quit: ";

               cin >> ch;

               if (ch=='Q' && ch=='q') 

        { 

        cout << "Exiting...";

                           }

               else

               cout << "Please press Q or q to quit: ";

 }





//Main Program

int main ()

{

                

           

                           char filename [80];

                           Open_Price_Data_File (filename);

                           struct Bar* Array;

                           Array = Define_Array (filename);

                           Parse_Output_To_File (Array, filename);

                           Date_Verification (Array);

                                                     ExitScreen ();

                           return 0;

}