Stock Class Reference

A class that represents a stock object in the game. More...

#include "stock.h"

Collaboration diagram for Stock:

Public Member Functions
	Stock (void)
	Constructor of class Stock.
void	add_event (const Stock_event &event)
	Add an event to the stock.
float	calculateStockValue (const float &trading_fees_percent) const
	Calculate the total value of the stocks the player is holding.
float	calculateTradingFeesLost (const float &trading_fees_percent) const
	Calculate the amount of money player lost due to trading fees.
bool	can_add_event (const Stock_event &event)
	Check if we can add the event to the stock.
std::string	category_name (void) const
	Return the name of the category the stock belongs to.
void	change_mean (float delta_mean)
	Change the mean of the stock by delta_mean.
float	delta_price (void)
	Return the change of stock price using the most recent price and the current price.
float	delta_price_percentage (void)
	Return the percentage of change of stock price.
float	get_base_attribute (stock_modifiers attribute)
	Get the base value of stock_attributes of the stock.
unsigned int	get_category (void)
	Get the category of the stock.
float	get_event_attribute (stock_modifiers attribute)
	Get the total change of attribute of the stock due to events only.
std::vector< unsigned int >	get_event_ids (void)
	Get the event ids of all the events that will apply to this stock specifically.
std::list< Stock_event >	get_events (void)
	Return all the events that will apply to this stock specifically.
unsigned int	get_history_size (void)
	Get size of the history.
float	get_initial_price (void)
	Get the initial price of the stock.
std::string	get_name (void)
	Get the name of the stock.
float	get_price (void)
	Get the price of the stock.
unsigned int	get_quantity (void)
	Get the quantity of the stock.
unsigned int	get_split_count (void)
	Get the split count of the stock.
float	get_total_attribute (stock_modifiers attribute)
	Sums up get_base_attribute() and get_event_attribute().
void	load (const std::string &playerName, int i)
	Load the stock from a file.
void	next_round (void)
	Call this when the game proceed to next round.
unsigned int	num_stocks_affordable (float balance, float trading_fees_percent) const
float	purchase (float &balance, unsigned int amount, float trading_fees_percent)
	Purchase a given number of stocks.
std::vector< float >	return_most_recent_history (unsigned int rounds)
	Get the stock price of recent rounds.
void	save (const std::string &playerName, int i)
	Save the stock from a file.
float	sell (float &balance, unsigned int amount, float trading_fees_percent)
	Sell a given number of stocks.
Stock_event	setup_STOCK_SPLIT_EVENT (void)
	Set up a getStockSplitEvent() with proper values.

Private Member Functions
void	remove_obselete_event (void)
	Remove obselete events from the list events that durations are less than/equal to 0 (In other words, expired).
void	update_history (void)
	Update the history array with the current price.

Private Attributes
std::map< stock_modifiers, float >	attributes
	Stores the initial value of the stock_modifiers (e.g.
unsigned int	category
	Use numbers to represent the category of the stock.
std::list< Stock_event >	events
	Stores all the events that will apply to this stock specifically.
std::vector< float >	history
	Contains the stock price history.
std::string	name
	Name of the stock that we assigned to it.
float	price
	Current price of the stock.
unsigned int	quantity
	Number of stocks the player has purchased.
unsigned int	split_count
	Contains the spliting count of a stock.

Friends
std::ostream &	operator<< (std::ostream &fout, const Stock &stock)
std::istream &	operator>> (std::istream &fin, Stock &stock)

Detailed Description

A class that represents a stock object in the game.

The stock has a name, price, quantity, category, money spent, events, attributes, and history. The stock can be purchased, sold, and updated.

Note

Example usage:

// Create a stock object. The constructor will initialize the stock automatically.
Stock stock;
// Purchase a stock.
float balance = 1000; stock.purchase(balance, 1, 0.01);
// Sell a stock.
stock.sell(balance, 1, 0.01);
// What is the name of the stock?
std::string name = stock.get_name();
// Get the upper limit of the percentage change of the stock price:
float upper_limit = stock.get_total_attribute(stock_modifiers::upper_limit);

Definition at line 55 of file stock.h.

Constructor & Destructor Documentation

Stock()

Stock::Stock

(

void

)

Constructor of class Stock.

The distribution of initial stock price will be consistent across the same categories. Note that the value '3' is because currently init_stock_price has 3 possible input values.

Definition at line 29 of file stock.cpp.

                 {
    category = random_integer(category_list_size);
    name = generate_name(category, 1)[0];
    /** The distribution of initial stock price will be consistent across the same
     * categories.
     * Note that the value '3' is because currently init_stock_price has 3
     * possible input values.
     */
    price = init_stock_price(category % 3 + 1);
    quantity = 0;
    attributes[standard_deviation] = init_sd();
    attributes[mean] = defaultMean;
    attributes[lower_limit] = defaultLowerLimit;
    attributes[upper_limit] = defaultUpperLimit;
    split_count = 0;
    update_history();
}

References attributes, category, category_list_size, defaultLowerLimit, defaultMean, defaultUpperLimit, generate_name(), init_sd(), init_stock_price(), lower_limit, mean, name, price, quantity, random_integer(), split_count, standard_deviation, update_history(), and upper_limit.

Here is the call graph for this function:

Member Function Documentation

add_event()

void Stock::add_event

(

const Stock_event &

event

)

Add an event to the stock.

Parameters

event

The event to be added. See events.h for more information about the class Stock_Event.

Definition at line 210 of file stock.cpp.

                                               {
    if (!can_add_event(event)) {
        // If the event is mutually exclusive with ongoing events,
        // ignore it and do nothing.
        return;
    }
    // If the event does not exist, add it to the std::list of events
    // Otherwise, update the duration of the event by deleting the old one and add the
    // new one.
    std::list<Stock_event>::iterator event_itr = events.begin();
    while (event_itr != events.end()) {
        if (*event_itr == event) {
            event_itr = events.erase(event_itr);
        }
        else {
            event_itr++;
        }
    }
    events.emplace_back(event);
}

References can_add_event(), and events.

Referenced by new_events_next_round(), and next_round().

Here is the call graph for this function:

Here is the caller graph for this function:

calculateStockValue()

float Stock::calculateStockValue

(

const float &

trading_fees_percent

)

const

Calculate the total value of the stocks the player is holding.

Parameters

trading_fees_percent

The trading fees percentage we charge the player. Set to 0 if you want to exclude trading fees from calculation.

Returns

The total value of the stocks.

Definition at line 371 of file stock.cpp.

                                                                         {
    return price * quantity * (1 - trading_fees_percent);
}

References price, quantity, and trading_fees_percent.

calculateTradingFeesLost()

float Stock::calculateTradingFeesLost

(

const float &

trading_fees_percent

)

const

Calculate the amount of money player lost due to trading fees.

Parameters

trading_fees_percent

The trading fees percentage we charge the player.

Returns

The amount of money player lost due to trading fees.

Definition at line 375 of file stock.cpp.

                                                                              {
    return price * quantity * trading_fees_percent;
}

References price, quantity, and trading_fees_percent.

can_add_event()

bool Stock::can_add_event

(

const Stock_event &

event

)

Check if we can add the event to the stock.

Note

A event can be added if the event is not mutually exclusive with any of the existing events.

Parameters

event

The event to be added.

Returns

True if the event can be added. False otherwise.

Definition at line 231 of file stock.cpp.

                                                   {
    std::list<Stock_event>::iterator event_itr = events.begin();
    while (event_itr != events.end()) {
        if (!event_itr->mutually_exclusive_events.empty()) {
            for (unsigned int i = 0; i < event_itr->mutually_exclusive_events.size();
                 i++) {
                if (event_itr->mutually_exclusive_events[i] == event.event_id) {
                    return false;
                }
            }
        }
        event_itr++;
    }
    return true;
}

References Stock_event::event_id, and events.

Referenced by add_event(), and new_events_next_round().

Here is the caller graph for this function:

category_name()

std::string Stock::category_name

(

void

)

const

Return the name of the category the stock belongs to.

Returns

Name of the category as a string.

Definition at line 164 of file stock.cpp.

{ return category_list[category]; }

References category, and category_list.

change_mean()

void Stock::change_mean ( float delta_mean )

inline

Change the mean of the stock by delta_mean.

Setter function.

Parameters

delta_mean

The change in mean.

Definition at line 205 of file stock.h.

{ attributes[mean] += delta_mean; }

References attributes, and mean.

delta_price()

float Stock::delta_price

(

void

)

Return the change of stock price using the most recent price and the current price.

Returns

change in stock price.

Definition at line 188 of file stock.cpp.

                             {
    // Stock prices are stored in the history array
    if (history.size() < 2) {
        // If there are less than two prices in the history array, return 0
        return 0;
    }
    // Return the change of the last two prices
    return history[history.size() - 1] - history[history.size() - 2];
}

References history.

Referenced by delta_price_percentage().

Here is the caller graph for this function:

delta_price_percentage()

float Stock::delta_price_percentage

(

void

)

Return the percentage of change of stock price.

Returns

Percentage of change in stock price. E.g. 0.05 means 5% increase in price.

If there are less than two prices in the history array, return 0 If the last two prices are negative, return 0, as it is not possible to calculate the percentage change

Definition at line 198 of file stock.cpp.

                                        {
    if (history.size() < 2 || history[history.size() - 1] < 0 ||
        history[history.size() - 2] < 0) {
        /** If there are less than two prices in the history array, return 0
         * If the last two prices are negative, return 0, as it is not possible to
         * calculate the percentage change
         */
        return 0;
    }
    return delta_price() / history[history.size() - 2];
}

References delta_price(), and history.

Here is the call graph for this function:

get_base_attribute()

float Stock::get_base_attribute ( stock_modifiers attribute )

inline

Get the base value of stock_attributes of the stock.

Getter function.

Parameters

attribute

The attribute to get. E.g. standard_deviation, mean, lower_limit, upper_limit

Returns

Base value of stock_attributes as float.

Definition at line 191 of file stock.h.

                                                            {
            return attributes[attribute];
        }

References attributes.

Referenced by getProcessedModifiers().

Here is the caller graph for this function:

get_category()

unsigned int Stock::get_category ( void )

inline

Get the category of the stock.

Getter function.

Returns

Category of the stock as unsigned int.

Definition at line 171 of file stock.h.

{ return category; }

References category.

get_event_attribute()

float Stock::get_event_attribute

(

stock_modifiers

attribute

)

Get the total change of attribute of the stock due to events only.

Getter function.
Example usage:

stock.get_base_attribute(stock_modifiers::standard_deviation);

Parameters

attribute

The attribute to get.

Returns

Total change of attribute due to Stock_event. Does not include the base value.

Definition at line 259 of file stock.cpp.

                                                          {
    float sum = 0;
    std::list<Stock_event>::iterator event_itr = events.begin();
    while (event_itr != events.end()) {
        sum += event_itr->modifiers[attribute];
        event_itr++; // Bug fix: infinite loop
    }
    return sum;
}

References events.

Referenced by get_total_attribute(), and getProcessedModifiers().

Here is the caller graph for this function:

get_event_ids()

std::vector< unsigned int > Stock::get_event_ids

(

void

)

Get the event ids of all the events that will apply to this stock specifically.

Getter function.

Returns

A vector of unsigned int.

Definition at line 307 of file stock.cpp.

                                                 {
    std::vector<unsigned int> event_ids;
    std::list<Stock_event>::iterator event_itr = events.begin();
    while (event_itr != events.end()) {
        event_ids.emplace_back(event_itr->event_id);
        event_itr++;
    }
    return event_ids;
}

References events.

get_events()

std::list< Stock_event > Stock::get_events ( void )

inline

Return all the events that will apply to this stock specifically.

Getter function.

Returns

A list of Stock_event.

Definition at line 212 of file stock.h.

{ return events; }

References events.

get_history_size()

unsigned int Stock::get_history_size ( void )

inline

Get size of the history.

Returns

Size of the history as unsigned int.

Definition at line 199 of file stock.h.

{ return history.size(); }

References history.

Referenced by getProcessedModifiers().

Here is the caller graph for this function:

get_initial_price()

float Stock::get_initial_price ( void )

inline

Get the initial price of the stock.

Getter function.

Returns

Initial price of the stock as float.

Definition at line 183 of file stock.h.

{ return history[0]; }

References history.

Referenced by getProcessedModifiers().

Here is the caller graph for this function:

get_name()

std::string Stock::get_name ( void )

inline

Get the name of the stock.

Getter function.

Returns

Name of the stock.

Definition at line 159 of file stock.h.

{ return name; }

References name.

Referenced by new_events_next_round().

Here is the caller graph for this function:

get_price()

float Stock::get_price ( void )

inline

Get the price of the stock.

Getter function.

Returns

Price of the stock as float.

Definition at line 165 of file stock.h.

{ return price; }

References price.

Referenced by getProcessedModifiers().

Here is the caller graph for this function:

get_quantity()

unsigned int Stock::get_quantity ( void )

inline

Get the quantity of the stock.

Getter function.

Returns

Stock.quantity as unsigned int.

Definition at line 177 of file stock.h.

{ return quantity; }

References quantity.

get_split_count()

unsigned int Stock::get_split_count ( void )

inline

Get the split count of the stock.

Getter function.

Returns

Stock.split_count as unsigned int.

Definition at line 225 of file stock.h.

{ return split_count; }

References split_count.

Referenced by percentage_change_price().

Here is the caller graph for this function:

get_total_attribute()

float Stock::get_total_attribute

(

stock_modifiers

attribute

)

Sums up get_base_attribute() and get_event_attribute().

Parameters

attribute

The attribute to get.

Returns

Total value of the attribute. float type.

Definition at line 317 of file stock.cpp.

                                                          {
    return attributes[attribute] + get_event_attribute(attribute);
}

References attributes, and get_event_attribute().

Referenced by getProcessedModifiers().

Here is the call graph for this function:

Here is the caller graph for this function:

load()

void Stock::load	(	const std::string &	playerName,
		int	i )

Load the stock from a file.

Parameters

playerName	The name of the player.
i	The index of the stock.

Definition at line 57 of file stock.cpp.

                                                    {
    std::string fileToBeLoaded;
    std::ifstream fin;
    fileToBeLoaded = SAVE_FOLDER_PREFIX + playerName + "/" + std::to_string(i) + "" +
                     SAVE_FILE_EXTENSION_TXT;
    std::cout << "Loading " << fileToBeLoaded << " ... ";
    fin.open(fileToBeLoaded.c_str());
    // get the first line, which is category
    fin >> *this; // use operator>> to load the Stock object
    fin.close();
    assert(price <= STOCK_PRICE_LIMIT && "Price exceed the limit");
    std::cout << "done" << std::endl;
}

References playerName, price, SAVE_FILE_EXTENSION_TXT, SAVE_FOLDER_PREFIX, and STOCK_PRICE_LIMIT.

next_round()

void Stock::next_round

(

void

)

Call this when the game proceed to next round.

Update the price of the stock. If the price is less than 1000, the price will increase or decrease by a random percentage. If the price is more than 1000, the price will be halved and the quantity will be doubled.

Definition at line 276 of file stock.cpp.

                           {
    /** Update the price of the stock.
     * If the price is less than 1000, the price will increase or decrease by a random
     * percentage. If the price is more than 1000, the price will be halved and the
     * quantity will be doubled.
     */
    float price_diff = percentage_change_price(*this) / 100;
    // Reduce all events duration by one.
    std::list<Stock_event>::iterator event_itr = events.begin();
    while (event_itr != events.end()) {
        if (event_itr->duration > durationDecreaseMultiplier) {
            event_itr->duration -= durationDecreaseMultiplier;
        }
        else {
            event_itr->duration = 0;
        }
        event_itr++;
    }
    if (!(price * (1 + price_diff) >= STOCK_PRICE_LIMIT)) {
        price *= (1 + price_diff);
    }
    else {
        price /= 2;
        quantity *= 2;
        split_count++;
        add_event(setup_STOCK_SPLIT_EVENT());
    }
    remove_obselete_event();
    update_history();
}

References add_event(), durationDecreaseMultiplier, events, percentage_change_price(), price, quantity, remove_obselete_event(), setup_STOCK_SPLIT_EVENT(), split_count, STOCK_PRICE_LIMIT, and update_history().

Here is the call graph for this function:

num_stocks_affordable()

unsigned int Stock::num_stocks_affordable	(	float	balance,
		float	trading_fees_percent ) const

Parameters

balance	The balance of the player.
trading_fees_percent	The trading fees percentage we charge the player.

Returns

Number of stocks that the player can afford with the balance.

Definition at line 166 of file stock.cpp.

                                                     {
    float value = balance / (price * (1 + trading_fees_percent));
    return value < 0 ? 0 : static_cast<unsigned int>(value);
}

References balance, price, and trading_fees_percent.

purchase()

float Stock::purchase	(	float &	balance,
		unsigned int	amount,
		float	trading_fees_percent )

Purchase a given number of stocks.

Parameters

balance	The balance ($) of the player. Pass-by-reference.
amount	The number of stocks to purchase.
trading_fees_percent	The trading fees percentage we charge the player.

Returns

Successful: Total cost of the purchase. Failed: -1 if the player does not have enough balance to buy the stock.

Definition at line 139 of file stock.cpp.

                                                                      {
    float total_cost = price * amount * (1 + trading_fees_percent);
    // Check if the player has enough balance to buy the stock
    if (total_cost > balance && price <= 0) {
        return INVALID_OPERATION;
    }
    // Update the balance, quantity, and money_spent
    balance -= total_cost;
    quantity += amount;
    return total_cost;
}

References balance, INVALID_OPERATION, price, quantity, and trading_fees_percent.

remove_obselete_event()

void Stock::remove_obselete_event ( void )

private

Remove obselete events from the list events that durations are less than/equal to 0 (In other words, expired).

For internal use after the Stock::next_round function is called.

Definition at line 247 of file stock.cpp.

                                      {
    std::list<Stock_event>::iterator event_itr = events.begin();
    while (event_itr != events.end()) {
        if (event_itr->duration <= 0) {
            event_itr = events.erase(event_itr);
        }
        else {
            event_itr++;
        }
    }
}

References events.

Referenced by next_round().

Here is the caller graph for this function:

return_most_recent_history()

std::vector< float > Stock::return_most_recent_history

(

unsigned int

rounds

)

Get the stock price of recent rounds.

Parameters

rounds

The number of rounds to look back. 5 means the last 5 rounds.

Returns

A vector of stock prices. If the number of rounds is greater than the history size, return the whole history. Otherwise, return the most recent rounds. If the history is empty, return an empty vector.

Definition at line 177 of file stock.cpp.

                                                                      {
    std::vector<float> recent_history;
    if (rounds >= history.size()) {
        return history;
    }
    for (unsigned int i = history.size() - rounds; i < history.size(); i++) {
        recent_history.emplace_back(history[i]);
    }
    return recent_history;
}

References history.

save()

void Stock::save	(	const std::string &	playerName,
		int	i )

Save the stock from a file.

Parameters

playerName	The name of the player.
i	The index of the stock.

Definition at line 47 of file stock.cpp.

                                                    {
    std::string filesave;
    std::ofstream fout;
    filesave = SAVE_FOLDER_PREFIX + playerName + "/" + std::to_string(i) + "" +
               SAVE_FILE_EXTENSION_TXT; // creating the file path
    fout.open(filesave.c_str());
    fout << *this; // use operator<< to save the Stock object
    fout.close();
}

References playerName, SAVE_FILE_EXTENSION_TXT, and SAVE_FOLDER_PREFIX.

sell()

float Stock::sell	(	float &	balance,
		unsigned int	amount,
		float	trading_fees_percent )

Sell a given number of stocks.

Parameters

balance	The balance ($) of the player. Pass-by-reference.
amount	The number of stocks to sell.
trading_fees_percent	The trading fees percentage we charge the player.

Returns

Successful: Amount of money the player receive. Failed: -1 if the player does not have enough stocks to sell.

Definition at line 152 of file stock.cpp.

                                                                                  {
    // Check if the player has enough stocks to sell
    if (quantity < amount && price <= 0) {
        return INVALID_OPERATION;
    }
    // Calculate the total revenue
    float total_revenue = price * amount * (1 - trading_fees_percent);
    balance += total_revenue;
    quantity -= amount;
    return total_revenue;
}

References balance, INVALID_OPERATION, price, quantity, and trading_fees_percent.

setup_STOCK_SPLIT_EVENT()

Stock_event Stock::setup_STOCK_SPLIT_EVENT

(

void

)

Set up a getStockSplitEvent() with proper values.

Definition at line 269 of file stock.cpp.

                                               {
    Stock_event event_copy = getStockSplitEvent();
    event_copy.text = name + event_copy.text;
    event_copy.category = category;
    return event_copy;
}

References category, Stock_event::category, getStockSplitEvent(), name, and Stock_event::text.

Referenced by next_round().

Here is the call graph for this function:

Here is the caller graph for this function:

update_history()

void Stock::update_history ( void )

private

Update the history array with the current price.

We use vector now!

Definition at line 172 of file stock.cpp.

                               {
    /** We use vector now! */
    history.emplace_back(price);
}

References history, and price.

Referenced by Stock(), and next_round().

Here is the caller graph for this function:

Friends And Related Symbol Documentation

operator<<

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

friend

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 )

friend

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;
}

Member Data Documentation

attributes

std::map<stock_modifiers, float> Stock::attributes

private

Stores the initial value of the stock_modifiers (e.g.

standard deviation, mean and limits).

Definition at line 289 of file stock.h.

Referenced by Stock(), change_mean(), get_base_attribute(), and get_total_attribute().

category

unsigned int Stock::category

private

Use numbers to represent the category of the stock.

Note

The range of the numbers should be [0, category_list_size - 1]. category_list_size

Definition at line 282 of file stock.h.

Referenced by Stock(), category_name(), get_category(), and setup_STOCK_SPLIT_EVENT().

events

std::list<Stock_event> Stock::events

private

Stores all the events that will apply to this stock specifically.

Definition at line 285 of file stock.h.

Referenced by add_event(), can_add_event(), get_event_attribute(), get_event_ids(), get_events(), next_round(), and remove_obselete_event().

history

std::vector<float> Stock::history

private

Contains the stock price history.

First element (index 0) is the oldest.

Definition at line 293 of file stock.h.

Referenced by delta_price(), delta_price_percentage(), get_history_size(), get_initial_price(), return_most_recent_history(), and update_history().

name

std::string Stock::name

private

Name of the stock that we assigned to it.

Definition at line 270 of file stock.h.

Referenced by Stock(), get_name(), and setup_STOCK_SPLIT_EVENT().

price

float Stock::price

private

Current price of the stock.

Definition at line 273 of file stock.h.

Referenced by Stock(), calculateStockValue(), calculateTradingFeesLost(), get_price(), load(), next_round(), num_stocks_affordable(), purchase(), sell(), and update_history().

quantity

unsigned int Stock::quantity

private

Number of stocks the player has purchased.

Definition at line 276 of file stock.h.

Referenced by Stock(), calculateStockValue(), calculateTradingFeesLost(), get_quantity(), next_round(), purchase(), and sell().

split_count

unsigned int Stock::split_count

private

Contains the spliting count of a stock.

Definition at line 296 of file stock.h.

Referenced by Stock(), get_split_count(), and next_round().

---

The documentation for this class was generated from the following files:

• include/stock.h
• src/stock.cpp