.. _program_listing_file_examples_state_concept_usage.cpp:

Program Listing for File state_concept_usage.cpp
================================================

|exhale_lsh| :ref:`Return to documentation for file <file_examples_state_concept_usage.cpp>` (``examples/state_concept_usage.cpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #include <iostream>
   #include <vector>
   #include <array>
   #include <deque>
   #include "core/concepts.hpp"
   
   // Example function that works with any system_state-satisfying type
   template<system_state S>
   void print_state_info(const S& state) {
       std::cout << "State type: " << typeid(S).name() << std::endl;
       std::cout << "Size: " << state.size() << std::endl;
       std::cout << "Values: ";
       for (const auto& value : state) {
           std::cout << value << " ";
       }
       std::cout << std::endl << std::endl;
   }
   
   // Example function that modifies a state
   template<system_state S>
   void initialize_state(S& state, typename S::value_type initial_value = {}) {
       for (std::size_t i = 0; i < state.size(); ++i) {
           auto it = state.begin();
           it[i] = initial_value + static_cast<typename S::value_type>(i);
       }
   }
   
   int main() {
       std::cout << "State Concept Usage Examples" << std::endl;
       std::cout << "============================" << std::endl << std::endl;
       
       // Example 1: std::vector<double> (common for numerical computations)
       std::vector<double> vector_state(5);
       initialize_state(vector_state, 1.0);
       std::cout << "Example 1 - Vector State:" << std::endl;
       print_state_info(vector_state);
       
       // Example 2: std::array<float, 4> (fixed-size, good for small states)
       std::array<float, 4> array_state;
       initialize_state(array_state, 2.5f);
       std::cout << "Example 2 - Array State:" << std::endl;
       print_state_info(array_state);
       
       // Example 3: std::deque<int> (good for dynamic resizing)
       std::deque<int> deque_state(3);
       initialize_state(deque_state, 10);
       std::cout << "Example 3 - Deque State:" << std::endl;
       print_state_info(deque_state);
       
       // Example 4: Custom state class
       class CustomState {
       public:
           using value_type = double;
           
           std::vector<double> data;
           std::string name;
           
           CustomState(const std::string& n, std::size_t size) 
               : data(size, 0.0), name(n) {}
           
           std::size_t size() const { return data.size(); }
           auto begin() { return data.begin(); }
           auto end() { return data.end(); }
           auto begin() const { return data.begin(); }
           auto end() const { return data.end(); }
           
           // Add array indexing access required by system_state concept
           double& operator[](std::size_t index) { return data[index]; }
           const double& operator[](std::size_t index) const { return data[index]; }
           
           const std::string& get_name() const { return name; }
       };
       
       CustomState custom_state("MyState", 6);
       initialize_state(custom_state, 0.5);
       std::cout << "Example 4 - Custom State (name: " << custom_state.get_name() << "):" << std::endl;
       print_state_info(custom_state);
       
       return 0;
   }