Skip to content

Commit dddb27e

Browse files
nikselkonikselko
authoredApr 12, 2021
Add files via upload
1 parent c9db931 commit dddb27e

10 files changed

+721
-0
lines changed
 

‎dev_includes.h

+18
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
/******************************************************************************
2+
* *
3+
* Program : Message processor *
4+
* *
5+
* Date : 11 / 04 / 2021 *
6+
* *
7+
* Programmer : Nikita Seliverstov (nikselko) *
8+
* *
9+
* *
10+
******************************************************************************/
11+
12+
#pragma once
13+
14+
#include <string>
15+
#include <ctime>
16+
#include <iostream>
17+
18+
using namespace std;

‎dev_main.cpp

+93
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,93 @@
1+
/******************************************************************************
2+
* *
3+
* Program : Message processor *
4+
* *
5+
* Date : 11 / 04 / 2021 *
6+
* *
7+
* Programmer : Nikita Seliverstov (nikselko) *
8+
* *
9+
* *
10+
******************************************************************************/
11+
12+
#include "dev_message_reader.h"
13+
14+
int main()
15+
{
16+
{ /* MANUAL INITIALIZATION TEST */
17+
Message_Broker broker_manual_init;
18+
19+
Message msg0(TargetType::dev_air_purifier, 123, "SET ON"); // Creations of Message objects
20+
Message msg1(TargetType::dev_temperature_sensor, 234, "SET ON"); //
21+
Message msg2(TargetType::dev_air_purifier, 123, "SET OFF"); //
22+
Message msg3(TargetType::dev_air_purifier, 123, "SET ON"); //
23+
Message msg4(TargetType::dev_temperature_sensor, 234, "MEASURE"); //
24+
Message msg5(TargetType::dev_air_purifier, 123, "SET MODE PURIFY"); //
25+
Message msg6(TargetType::dev_heater, 321, "SET ON"); //
26+
27+
broker_manual_init.add(msg0); // Adding Message objects to broker vector
28+
broker_manual_init.add(msg1); //
29+
broker_manual_init.add(msg2); //
30+
broker_manual_init.add(msg3); //
31+
broker_manual_init.add(msg4); //
32+
broker_manual_init.add(msg5); //
33+
broker_manual_init.add(msg6); //
34+
35+
cout << "-MANUAL INITIALIZATION OUTPUT-" << endl; // Print all manual-initialized messages
36+
cout << "--ALL BROKER MESSAGES" << endl; //
37+
broker_manual_init.print(); //
38+
cout << "Messages printed: "; //
39+
cout << broker_manual_init.count(); //
40+
cout << "\n\n"; //
41+
42+
cout << "--BROKER MESSAGES (target_id: 234)" << endl; // Print manual-initialized messages with target_id = 234
43+
broker_manual_init.print(234); //
44+
cout << "Messages printed (target_id: 234): "; //
45+
cout << broker_manual_init.count(234); //
46+
cout << "\n\n"; //
47+
48+
cout << "--POP 1st MESSAGE IN BROKER " << " (target_id: 234)" << endl; // Print popped messages with target_id = 234
49+
cout << broker_manual_init.pop_message_for(234).as_string() << endl; //
50+
cout << "\n\n"; //
51+
52+
cout << "--ALL BROKER MESSAGES AFTER POPING " << endl; // Print all manual-initialized messages after pop
53+
broker_manual_init.print(); //
54+
cout << "Messages printed: "; //
55+
cout << broker_manual_init.count(); //
56+
cout << "\n\n\n"; //
57+
}
58+
59+
{ /* FILE INITIALIZATION TEST */
60+
std::string file_name = "dev_messages.txt";
61+
Message_Broker broker_file_init;
62+
Message_Reader reader{ file_name };
63+
64+
while (reader.has_next()) // Fixed file-initialization, no more errors with const
65+
{ //
66+
auto msg = reader.read_next(); //
67+
broker_file_init.add(msg); //
68+
} //
69+
70+
cout << "-FILE INITIALIZATION OUTPUT-" << endl; // Print all file-initialized messages
71+
cout << "--ALL BROKER MESSAGES FOR "<< file_name << endl; //
72+
broker_file_init.print(); //
73+
cout << "Messages printed: "; //
74+
cout << broker_file_init.count(); //
75+
cout << "\n\n"; //
76+
77+
cout << "--BROKER MESSAGES FOR " << file_name << " (target_id: 324)" << endl; // Print file-initialized messages with target_id = 324
78+
broker_file_init.print(324); //
79+
cout << "Messages printed (target_id: 324): "; //
80+
cout << broker_file_init.count(324); //
81+
cout << "\n\n"; //
82+
83+
cout << "--POP 1st MESSAGE FOR " << file_name << " (target_id: 324)" << endl; // Print popped message with target_id = 324
84+
cout << broker_file_init.pop_message_for(324).as_string() << endl; //
85+
cout << "\n\n"; //
86+
87+
cout << "--ALL BROKER MESSAGES AFTER POPING " << file_name << endl; // Print all file-initialized messages after pop
88+
broker_file_init.print(); //
89+
cout << "Messages printed: "; //
90+
cout << broker_file_init.count(); //
91+
cout << "\n\n"; //
92+
}
93+
}

‎dev_message.cpp

+116
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,116 @@
1+
/******************************************************************************
2+
* *
3+
* Program : Message processor *
4+
* *
5+
* Date : 11 / 04 / 2021 *
6+
* *
7+
* Programmer : Nikita Seliverstov (nikselko) *
8+
* *
9+
* *
10+
******************************************************************************/
11+
12+
#include "dev_message.h"
13+
14+
long Message::new_id()
15+
{
16+
static long id = 0x1000;
17+
return ++id;
18+
}
19+
20+
std::string type_to_str(TargetType m_type)
21+
{
22+
switch (m_type) // Wwitch was used to write less code,
23+
{
24+
case TargetType::dev_temperature_sensor: return "temperature_sensor"; break;
25+
case TargetType::dev_pressure_sensor: return "pressure_sensor"; break;
26+
case TargetType::dev_humidity_sensor: return "humidity_sensor"; break;
27+
case TargetType::dev_heater: return "heater"; break;
28+
case TargetType::dev_air_purifier: return "air_purifier"; break;
29+
case TargetType::UNKNOWN: return "UNKNOWN"; break;
30+
}
31+
32+
return "UNKNOWN"; // Enumerated logic: if(m_type < TargetType::UNKNOWN) return type_name[m_type]; - was tested and works well
33+
}
34+
35+
long long Message::generate_timestamp()
36+
{
37+
long long l_time;
38+
39+
if (time(&l_time))
40+
return l_time;
41+
else
42+
return 0;
43+
}
44+
45+
Message::Message() :
46+
timestamp{ generate_timestamp() },
47+
target_type{ TargetType::UNKNOWN },
48+
target_id{ 0 },
49+
message_id{ new_id() },
50+
text{ "" } {}
51+
52+
Message::Message(TargetType m_target_type, long m_target_id, std::string m_text) :
53+
timestamp{ generate_timestamp() },
54+
target_type{ m_target_type },
55+
target_id{ m_target_id },
56+
message_id{ new_id() },
57+
text{ m_text } {}
58+
59+
const long Message::get_message_id()
60+
{
61+
return message_id;
62+
}
63+
64+
const long Message::get_target_id()
65+
{
66+
return target_id;
67+
}
68+
69+
const TargetType Message::get_target_type()
70+
{
71+
return target_type;
72+
}
73+
74+
const long long Message::get_timestamp()
75+
{
76+
return timestamp;
77+
}
78+
79+
const std::string Message::get_text()
80+
{
81+
return text;
82+
}
83+
84+
void Message::set_text(std::string m_text)
85+
{
86+
text = m_text;
87+
}
88+
89+
bool Message::is_valid()
90+
{
91+
if (target_type != TargetType::UNKNOWN)
92+
{
93+
if (text != "")
94+
return true;
95+
else
96+
return false;
97+
}
98+
else
99+
return false;
100+
}
101+
102+
std::string Message::as_string()
103+
{
104+
std::string tmp_return = "[message_id: "
105+
+ std::to_string(message_id)
106+
+ ", timestamp: "
107+
+ std::to_string(timestamp)
108+
+ ", target_id: "
109+
+ std::to_string(target_id)
110+
+ ", target_type: "
111+
+ type_to_str(target_type)
112+
+ "]: "
113+
+ text;
114+
115+
return tmp_return;
116+
}

‎dev_message.h

+119
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,119 @@
1+
/******************************************************************************
2+
* *
3+
* Program : Message processor *
4+
* *
5+
* Date : 11 / 04 / 2021 *
6+
* *
7+
* Programmer : Nikita Seliverstov (nikselko) *
8+
* *
9+
* *
10+
******************************************************************************/
11+
12+
#pragma once
13+
14+
#include "dev_includes.h"
15+
16+
#if __cplusplus < 199711L // Cpp version check
17+
18+
template <typename def, typename inner = typename def::type> // Safe enum for < (C++ < 11)
19+
class safe_enum : public def
20+
{
21+
typedef inner type;
22+
inner val;
23+
24+
public:
25+
safe_enum() {}
26+
safe_enum(type v) : val(v) {}
27+
type underlying() const { return val; }
28+
29+
friend bool operator == (const safe_enum& lhs, const safe_enum& rhs) { return lhs.val == rhs.val; }
30+
friend bool operator != (const safe_enum& lhs, const safe_enum& rhs) { return lhs.val != rhs.val; }
31+
friend bool operator < (const safe_enum& lhs, const safe_enum& rhs) { return lhs.val < rhs.val; }
32+
friend bool operator <= (const safe_enum& lhs, const safe_enum& rhs) { return lhs.val <= rhs.val; }
33+
friend bool operator > (const safe_enum& lhs, const safe_enum& rhs) { return lhs.val > rhs.val; }
34+
friend bool operator >= (const safe_enum& lhs, const safe_enum& rhs) { return lhs.val >= rhs.val; }
35+
};
36+
37+
class TargetType // Safe enum implementation for (C++ < 11)
38+
{
39+
enum type {
40+
dev_temperature_sensor,
41+
dev_pressure_sensor,
42+
dev_humidity_sensor,
43+
dev_heater,
44+
dev_air_purifier,
45+
UNKNOWN
46+
};
47+
};
48+
typedef safe_enum<TargetType, int> Target_Type;
49+
50+
#else
51+
52+
enum class TargetType // Enum-Class aka Scoped-Enumeration. Makes it both strongly typed and strongly scoped (C++ > 11)
53+
{
54+
dev_temperature_sensor,
55+
dev_pressure_sensor,
56+
dev_humidity_sensor,
57+
dev_heater,
58+
dev_air_purifier,
59+
UNKNOWN
60+
};
61+
62+
inline TargetType& operator ++ (TargetType& to_increment) // Scoped-enumeration incrementing operator for Prefix
63+
{
64+
to_increment = TargetType(unsigned(to_increment) + 1);
65+
return to_increment;
66+
}
67+
68+
inline TargetType operator ++ (TargetType& to_increment, int) // Scoped-enumeration incrementing operator for Postfix
69+
{
70+
TargetType tmp_result = to_increment;
71+
++to_increment;
72+
return tmp_result;
73+
}
74+
75+
inline TargetType& operator -- (TargetType& to_increment) // Scoped-enumeration decrementing operator for Prefix
76+
{
77+
to_increment = TargetType(unsigned(to_increment) - 1);
78+
return to_increment;
79+
}
80+
81+
inline TargetType operator -- (TargetType& to_increment, int) // Scoped-enumeration decrementing operator for Postfix
82+
{
83+
TargetType tmp_result = to_increment;
84+
--to_increment;
85+
return tmp_result;
86+
}
87+
88+
#endif
89+
90+
std::string type_to_str(TargetType m_type); // Translate function (non class)
91+
92+
class Message // Message class implementation: -msg_id -trg_id -trg_t -ts -txt
93+
{
94+
private:
95+
long message_id;
96+
long target_id;
97+
TargetType target_type;
98+
long long timestamp;
99+
std::string text;
100+
101+
static long new_id();
102+
long long generate_timestamp();
103+
104+
public:
105+
Message();
106+
Message(TargetType m_target_type, long m_target_id, std::string m_text);
107+
108+
const long get_message_id();
109+
const long get_target_id();
110+
111+
const TargetType get_target_type();
112+
const long long get_timestamp();
113+
114+
const std::string get_text();
115+
void set_text(std::string m_text);
116+
117+
bool is_valid();
118+
std::string as_string();
119+
};

‎dev_message_broker.cpp

+117
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,117 @@
1+
/******************************************************************************
2+
* *
3+
* Program : Message processor *
4+
* *
5+
* Date : 11 / 04 / 2021 *
6+
* *
7+
* Programmer : Nikita Seliverstov (nikselko) *
8+
* *
9+
* *
10+
******************************************************************************/
11+
12+
#include "dev_message_broker.h"
13+
14+
Message_Broker::Message_Broker() : _count(0) {}
15+
16+
void Message_Broker::add(const Message& m_Message)
17+
{
18+
Messages.push_back(m_Message); // Vector push_back is used with count incrementing
19+
_count++;
20+
}
21+
22+
void Message_Broker::add(TargetType m_target_type, long m_target_id, std::string m_text)
23+
{
24+
auto tmp_Message = Message::Message(m_target_type, m_target_id, m_text);
25+
Messages.push_back(tmp_Message); // Vector push_back is used with count incrementing
26+
_count++;
27+
}
28+
29+
const int Message_Broker::count()
30+
{
31+
return _count;
32+
}
33+
34+
const int Message_Broker::count(long m_target_id)
35+
{
36+
int tmp_counter = 0; // Temporary variable was used to avoid warnings about empty return-cases
37+
38+
for (int i = 0; i < count(); i++)
39+
{
40+
if (Messages.at(i).get_target_id() == m_target_id)
41+
tmp_counter++;
42+
}
43+
44+
return tmp_counter;
45+
}
46+
47+
Message& Message_Broker::peek_message_for(long m_target_id)
48+
{
49+
size_t tmp_position{}; // Temporary variable was used to avoid warnings about empty return-cases
50+
51+
if (count() != 0)
52+
{
53+
for (int i = 0; i < count(); i++)
54+
{
55+
if (Messages.at(i).get_target_id() == m_target_id)
56+
tmp_position = i;
57+
}
58+
}
59+
60+
return Messages.at(tmp_position);
61+
}
62+
63+
Message& Message_Broker::peek_message_for(std::vector<Message>& m_vec, long m_target_id) const
64+
{
65+
size_t tmp_position{}; // Temporary variable was used to avoid warnings about empty return-cases
66+
67+
for (size_t i = 0; i < m_vec.size(); i++)
68+
{
69+
if (m_vec.at(i).get_target_id() == m_target_id)
70+
tmp_position = i;
71+
}
72+
73+
return m_vec.at(tmp_position);
74+
}
75+
76+
Message Message_Broker::pop_message_for(long m_target_id)
77+
{
78+
Message* tmp_Message = new Message; // Temporary Message object for return
79+
80+
if (count() != 0)
81+
{
82+
for (int i = 0; i < count(); i++)
83+
{
84+
if (Messages.at(i).get_target_id() == m_target_id)
85+
{
86+
*tmp_Message = Messages.at(i);
87+
remove_at_index(Messages, i); // Delete message object
88+
_count--;
89+
break;
90+
}
91+
}
92+
}
93+
94+
return *tmp_Message;
95+
}
96+
97+
void Message_Broker::remove_at_index(std::vector<Message>& vec, int index) // Proper way to vector remove element
98+
{
99+
auto to_remove = vec.begin();
100+
std::advance(to_remove, index);
101+
vec.erase(to_remove);
102+
}
103+
104+
const void Message_Broker::print()
105+
{
106+
for (int i = 0; i < count(); i++)
107+
cout << Messages.at(i).as_string() << endl;
108+
}
109+
110+
const void Message_Broker::print(long m_target_id)
111+
{
112+
for (int i = 0; i < count(); i++)
113+
{
114+
if (Messages.at(i).get_target_id() == m_target_id)
115+
cout << Messages.at(i).as_string() << endl;
116+
}
117+
}

‎dev_message_broker.h

+42
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,42 @@
1+
/******************************************************************************
2+
* *
3+
* Program : Message processor *
4+
* *
5+
* Date : 11 / 04 / 2021 *
6+
* *
7+
* Programmer : Nikita Seliverstov (nikselko) *
8+
* *
9+
* *
10+
******************************************************************************/
11+
12+
#pragma once
13+
14+
#include "dev_message.h"
15+
#include <vector>
16+
17+
class Message_Broker // Message broker class implementation: -count -messages_vector
18+
{
19+
private:
20+
int _count;
21+
std::vector<Message> Messages;
22+
23+
void remove_at_index(std::vector<Message>& vec, int index);
24+
public:
25+
Message_Broker();
26+
27+
void add(const Message&);
28+
void add(TargetType m_target_type, long m_target_id, std::string m_text);
29+
30+
const int count();
31+
const int count(long target_id);
32+
33+
Message& peek_message_for(long m_target_id);
34+
Message& peek_message_for(std::vector<Message>& m_vec, long m_target_id) const; // Overloaded const function cannot operate non const declared vector, so we pass it as argument
35+
36+
Message pop_message_for(long target_id);
37+
38+
39+
const void print(long m_target_id);
40+
const void print();
41+
};
42+

‎dev_message_reader.cpp

+88
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,88 @@
1+
/******************************************************************************
2+
* *
3+
* Program : Message processor *
4+
* *
5+
* Date : 11 / 04 / 2021 *
6+
* *
7+
* Programmer : Nikita Seliverstov (nikselko) *
8+
* *
9+
* *
10+
******************************************************************************/
11+
12+
#include "dev_message_reader.h"
13+
14+
Message_Reader::Message_Reader(std::string m_file_name) : file_name{ m_file_name } // Constructor opens file and fills buffer with it
15+
{
16+
list.open(m_file_name);
17+
18+
if (list.is_open())
19+
buffer.assign((std::istreambuf_iterator<char>(list)), (std::istreambuf_iterator<char>()));
20+
21+
//list.close(); // For safety measures file closing can be added in the end of constructor
22+
}
23+
24+
bool Message_Reader::has_next() // Bool functions check presence of target_id and whatever target_type, if line meets this requirements it considered valid
25+
{
26+
auto tmp_line = buffer.substr(0, buffer.find("\n"));
27+
28+
if (buffer.length() > 1)
29+
{
30+
auto id_check = tmp_line.substr(0, tmp_line.find(" "));
31+
auto long_id_check = stol(id_check);
32+
33+
if (long_id_check > 0)
34+
{
35+
if (tmp_line.find("temperature_sensor")
36+
|| tmp_line.find("pressure_sensor")
37+
|| tmp_line.find("humidity_sensor")
38+
|| tmp_line.find("heater")
39+
|| tmp_line.find("air_purifier"))
40+
{
41+
return true;
42+
}
43+
else
44+
{
45+
if (list.is_open()) // If line cannot be read the list considered empty and file is closed
46+
list.close();
47+
return false;
48+
}
49+
}
50+
else
51+
{
52+
if (list.is_open())
53+
list.close();
54+
return false;
55+
}
56+
}
57+
else
58+
{
59+
if (list.is_open())
60+
list.close();
61+
return false;
62+
}
63+
}
64+
65+
Message Message_Reader::read_next() //PARSING ALGORYTHM DESCRIPTION (based on line deletion from buffer)
66+
{
67+
auto tmp_line = buffer.substr(0, buffer.find("\n")); // Temporary line for parsing a message
68+
auto tmp_line_init_length = tmp_line.length(); // Saving size of it, for deleting this line from the buffer in the end
69+
70+
auto id_parsed = tmp_line.substr(0, tmp_line.find(" ")); // ID parse
71+
long id_to_long = stol(id_parsed); //
72+
tmp_line.erase(0, id_parsed.length() + 1); // Clearing ID from Temporary line
73+
74+
auto target_type_parsed = tmp_line.substr(0, tmp_line.find(" ")); // Target Type parse
75+
TargetType tmp_type = TargetType::UNKNOWN; //
76+
for (auto i = TargetType::UNKNOWN; i >= TargetType::dev_temperature_sensor; i--) //
77+
{ //
78+
if (type_to_str(i) == target_type_parsed) // Comparison is performed on full name, so no mismatches can be met
79+
tmp_type = i; //
80+
} //
81+
tmp_line.erase(0, target_type_parsed.length() + 1); // Clearing Target type from Temporary line
82+
83+
auto text_parsed = tmp_line.substr(0, tmp_line.length()); // Message Text parse
84+
buffer.erase(0, tmp_line_init_length + 1); // Clearing initial size of Temporary Line from buffer ('+1' = \n)
85+
86+
return Message(tmp_type, id_to_long, text_parsed); // EXAMPLE MESSAGE: 756997 humidity_sensor MEASURE
87+
}
88+

‎dev_message_reader.h

+30
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
/******************************************************************************
2+
* *
3+
* Program : Message processor *
4+
* *
5+
* Date : 11 / 04 / 2021 *
6+
* *
7+
* Programmer : Nikita Seliverstov (nikselko) *
8+
* *
9+
* *
10+
******************************************************************************/
11+
12+
#pragma once
13+
14+
#include "dev_message_broker.h"
15+
#include <fstream>
16+
17+
class Message_Reader // Message reader class implementation: -file -buffer -file_name
18+
{
19+
private:
20+
ifstream list;
21+
std::string buffer;
22+
const std::string file_name;
23+
24+
public:
25+
Message_Reader(std::string m_file_name); // Constructor opens file
26+
27+
bool has_next(); // If next line is not readable closes file (tried to implement destructor with flcose() but it caused some errors)
28+
Message read_next();
29+
};
30+

‎dev_messages.txt

+22
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
324 temperature_sensor SET ON
2+
324 temperature_sensor SET UNIT C
3+
87534 heater SET ON
4+
756997 humidity_sensor MEASURE
5+
434 humidity_sensor SET ON
6+
756997 humidity_sensor MEASURE
7+
434 humidity_sensor MEASURE
8+
324 temperature_sensor MEASURE
9+
9763 air_purifier SET MODE PURIFY
10+
9763 air_purifier SET TARGET PM25 064
11+
434 humidity_sensor SET OFF
12+
9763 air_purifier MEASURE PM25
13+
756997 humidity_sensor MEASURE
14+
9763 air_purifier SET MODE HUMIDIFY
15+
87534 heater SELFTEST START
16+
87534 heater SELFTEST READY
17+
756997 humidity_sensor MEASURE
18+
87534 heater SELFTEST READY
19+
87534 heater SELFTEST READY
20+
87534 heater SELFTEST RESULTS
21+
87534 heater SET OFF
22+
324 temperature_sensor SET OFF

‎main.c

+76
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,76 @@
1+
#include <stdlib.h>
2+
#include <stdio.h>
3+
4+
#include "message.h"
5+
#include "message_api.h"
6+
#include "message_broker.h"
7+
#include "message_list.h"
8+
9+
int main(){
10+
printf("Hello, old C implementation!\n");
11+
message_t msg0 = create_message(123, dev_air_purifier, "SET ON");
12+
message_t msg1 = create_message(234, dev_temperature_sensor, "SET ON");
13+
message_t msg2 = create_message(123, dev_air_purifier, "SET OFF");
14+
message_t msg3 = create_message(123, dev_air_purifier, "SET ON");
15+
message_t msg4 = create_message(234, dev_temperature_sensor, "MEASURE");
16+
message_t msg5 = create_message(123, dev_air_purifier, "SET MODE PURIFY");
17+
message_t msg6 = create_message(321, dev_heater, "SET ON");
18+
19+
message_broker_t broker = create_broker();
20+
21+
push(&broker, &msg0);
22+
push(&broker, &msg1);
23+
push(&broker, &msg2);
24+
push(&broker, &msg3);
25+
push(&broker, &msg4);
26+
push(&broker, &msg5);
27+
push(&broker, &msg6);
28+
29+
int count = print_messages_for(&broker, 321);
30+
printf("Printed %d messages.\n", count);
31+
32+
message_t* msg = NULL;
33+
long target_id = 123;
34+
printf("Extracting messages for target_id=%ld\n", target_id);
35+
while((msg = next_message_for(&broker, target_id))){
36+
print_message(msg);
37+
free(msg);
38+
}
39+
printf("There are %d messages left fot target_id=%ld\n", count_messages_for(&broker, target_id), target_id);
40+
printf("THere are %ld messages left in broker\n", broker._count);
41+
42+
43+
target_id = 321;
44+
printf("Extracting messages for target_id=%ld\n", target_id);
45+
while((msg = next_message_for(&broker, target_id))){
46+
print_message(msg);
47+
free(msg);
48+
}
49+
printf("There are %d messages left fot target_id=%ld\n", count_messages_for(&broker, target_id), target_id);
50+
printf("There are %ld messages left in broker\n", broker._count);
51+
52+
const char* file_name = "messages.in";
53+
printf("\n\nReading the file %s\n\n", file_name);
54+
55+
if (!lst_open(file_name)){
56+
printf("Coudn't open file!\n");
57+
return EXIT_FAILURE;
58+
}
59+
60+
const message_t* pmessage = NULL;
61+
count = 0;
62+
while((pmessage = lst_read_next())){
63+
// FIXME: there's some error here about mixing const and non-const
64+
push(&broker, pmessage);
65+
++count;
66+
}
67+
68+
lst_close();
69+
printf("Finished reading the file with %d messages.\n", count);
70+
71+
printf("There are %ld messages in broker\n", broker._count);
72+
73+
74+
75+
return EXIT_SUCCESS;
76+
}

0 commit comments

Comments
 (0)
Please sign in to comment.