stock.cpp File Reference

Implementation of the Stock class. More...

#include "stock.h"
#include "file_io.h"
#include "format.h"
#include "names.h"
#include "random_price.h"
#include <algorithm>
#include <cassert>
#include <fstream>
#include <iostream>

Include dependency graph for stock.cpp:

Go to the source code of this file.

Functions
std::ostream &	operator<< (std::ostream &fout, const Stock &stock)
std::istream &	operator>> (std::istream &fin, Stock &stock)
void	sortStocksList (std::vector< Stock > &stocks_list, SortingMethods sortMethod, SortingDirections sortDirection)
	Sorts the stocks.

Variables
const int	INVALID_OPERATION = -1

Detailed Description

Implementation of the Stock class.

Definition in file stock.cpp.

Function Documentation

operator<<()

std::ostream & operator<<	(	std::ostream &	fout,
		const Stock &	stock )

Definition at line 71 of file stock.cpp.

                                                                {
    fout << stock.category
         << std::endl; // literally load everything into class into file
    fout << stock.name << std::endl;
    for (unsigned int index = 0; index < stock.history.size(); index++) {
        fout << stock.history[index] << " ";
    }
    fout << -1 << std::endl; // -1 is the stop code for vector<float> history in
                             // filesave
    fout << stock.quantity << std::endl;
    fout << stock.attributes.at(standard_deviation) << " ";
    fout << stock.attributes.at(mean) << " ";
    fout << stock.attributes.at(lower_limit) << " ";
    fout << stock.attributes.at(upper_limit) << std::endl;
    fout << stock.split_count << std::endl << std::endl;
 
    // Save the ongoing events, separated by std::endl
    for (Stock_event event : stock.events) {
        fout << event << std::endl;
    }
    return fout;
}

operator>>()

std::istream & operator>>	(	std::istream &	fin,
		Stock &	stock )

Definition at line 94 of file stock.cpp.

                                                         {
    fin >> stock.category; // line 1
    assert(stock.category < category_list_size && "Invalid category");
    //  line 2 is entirely the stock name
    std::getline(fin >> std::ws, stock.name);
    float loadedPrice;
    fin >> loadedPrice;
    // Erase the history vector and load the new history
    stock.history.clear();
    while (loadedPrice != -1) {
        stock.history.emplace_back(loadedPrice);
        fin >> loadedPrice; // line 3
    }
    // Set the price
    stock.price = stock.history.back();
    fin >> stock.quantity;                       // line 4
    fin >> stock.attributes[standard_deviation]; // line 5
    fin >> stock.attributes[mean];
    fin >> stock.attributes[lower_limit];
    fin >> stock.attributes[upper_limit];
    fin >> stock.split_count; // line 6
    // Clear the events list
    stock.events.clear();
    // Skip 2 empty lines
    std::string emptyLine;
    std::getline(fin >> std::ws, emptyLine);
    std::getline(fin >> std::ws, emptyLine);
    std::string loadedEventString;
    while (std::getline(fin, loadedEventString)) {
        Stock_event loadedEvent;
        std::istringstream(loadedEventString) >> loadedEvent;
        // Check the loaded event is valid
        if (loadedEvent.event_id == getStockSplitEvent().event_id) {
            stock.add_event(loadedEvent);
            continue;
        }
        assert(
            loadedEvent.event_id < all_stock_events.size() && "Invalid event loaded");
        Stock_event comparedEvent = all_stock_events[loadedEvent.event_id];
        assert(loadedEvent == comparedEvent && "Invalid event loaded");
        stock.add_event(loadedEvent);
    }
    return fin;
}

sortStocksList()

void sortStocksList	(	std::vector< Stock > &	stocks_list,
		SortingMethods	sortMethod = by_category,
		SortingDirections	sortDirection = ascending )

Sorts the stocks.

Parameters

stocks_list	A vector of stocks. Pass by reference to modify the stocks.
sortMethod	Sorting method. Default is by_category.
sortDirection	Sorting direction. True for ascending, false for descending. Default is ascending.

Definition at line 321 of file stock.cpp.

                                     {
    switch (sortMethod) {
        case by_name:
            std::sort(stocks_list.begin(), stocks_list.end(),
                [](Stock a, Stock b) { return a.get_name() < b.get_name(); });
            break;
        case by_category:
            std::sort(stocks_list.begin(), stocks_list.end(),
                [](Stock a, Stock b) { return a.get_category() < b.get_category(); });
            break;
        case by_price:
            std::sort(stocks_list.begin(), stocks_list.end(),
                [](Stock a, Stock b) { return a.get_price() < b.get_price(); });
            break;
        case by_quantity:
            std::sort(stocks_list.begin(), stocks_list.end(),
                [](Stock a, Stock b) { return a.get_quantity() < b.get_quantity(); });
            break;
        case by_sd:
            std::sort(stocks_list.begin(), stocks_list.end(), [](Stock a, Stock b) {
                return a.get_total_attribute(standard_deviation) <
                       b.get_total_attribute(standard_deviation);
            });
            break;
        case by_mean:
            std::sort(stocks_list.begin(), stocks_list.end(), [](Stock a, Stock b) {
                return a.get_total_attribute(mean) < b.get_total_attribute(mean);
            });
            break;
        case by_lower_limit:
            std::sort(stocks_list.begin(), stocks_list.end(), [](Stock a, Stock b) {
                return a.get_total_attribute(lower_limit) <
                       b.get_total_attribute(lower_limit);
            });
            break;
        case by_upper_limit:
            std::sort(stocks_list.begin(), stocks_list.end(), [](Stock a, Stock b) {
                return a.get_total_attribute(upper_limit) <
                       b.get_total_attribute(upper_limit);
            });
            break;
        default:
            break;
    }
    if (sortDirection == descending) {
        std::reverse(stocks_list.begin(), stocks_list.end());
    }
}

References by_category, by_lower_limit, by_mean, by_name, by_price, by_quantity, by_sd, by_upper_limit, and descending.

Referenced by main().

Here is the caller graph for this function:

Variable Documentation

INVALID_OPERATION

const int INVALID_OPERATION = -1

Definition at line 27 of file stock.cpp.

Referenced by Stock::purchase(), and Stock::sell().