-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathLoggingSharedObject.hpp
More file actions
92 lines (84 loc) · 3.72 KB
/
Copy pathLoggingSharedObject.hpp
File metadata and controls
92 lines (84 loc) · 3.72 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
//! \addtogroup 0005 Shared Objects
//! \brief This project is used to safely share objects between two or more threads.
//!
//! When multiple threads share one object, it is important that they do not
//! access and change the object at the same time. So SharedObjects is a
//! universal project that can be used throughout R2D2 so everyone uses
//! the same way to access and lock objects between multiple threads.
//! Developers do not need to implement their own way to
//! lock and release objects between threads.
//! This will reduce duplicated code in multiple projects.
//!
//! \file LoggingSharedObject.hpp
//! \author Koen van der Kruk 1654581
//! \date Created: 1-4-2016
//! \date Last Modified: 13-5-2016
//! \brief This class is used to log when an object is claimed and released.
//!
//! \copyright Copyright © 2016, HU University of Applied Sciences Utrecht.
//! All rights reserved.
//!
//! License: newBSD
//!
//! Redistribution and use in source and binary forms,
//! with or without modification, are permitted provided that
//! the following conditions are met:
//! - Redistributions of source code must retain the above copyright notice,
//! this list of conditions and the following disclaimer.
//! - Redistributions in binary form must reproduce the above copyright notice,
//! this list of conditions and the following disclaimer in the documentation
//! and/or other materials provided with the distribution.
//! - Neither the name of the HU University of Applied Sciences Utrecht
//! nor the names of its contributors may be used to endorse or promote
//! products derived from this software without specific prior written
//! permission.
//!
//! THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
//! "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
//! BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
//! AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//! IN NO EVENT SHALL THE HU UNIVERSITY OF APPLIED SCIENCES UTRECHT
//! BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
//! CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
//! PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
//! OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
//! WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
//! OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
//! EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// ~< HEADER_VERSION 2016 04 12 >~
#ifndef LOGGING_SHARED_OBJECT_H
#define LOGGING_SHARED_OBJECT_H
#include "SharedObject.hpp"
#include <mutex>
#include <iostream>
/// Class LoggingSharedObject
/// This class is used to log when an object is claimed and released.
/// \authors Koen van der Kruk
/// \version 1.0
/// \date 1-4-2016
template<typename T>
class LoggingSharedObject : public SharedObject<T> {
public:
/// Constructs the LoggingSharedObject with data as input
/// \param data_input The input data the loggingsharedobject can use to lock and unlock
/// \return A new LoggingSharedObject
LoggingSharedObject(T& data_input) :
SharedObject<T>(data_input)
{
}
protected:
/// This will claim the current object and it's data. This will also print out when the object is currently claimed.
void claim() override {
std::cout << "Object is currently claimed. " << std::endl;
lock_object.lock();
}
/// This will release the current object and it's data. This will also print out when the object is currently released.
void release() override {
std::cout << "Object is currently released. " << std::endl;
lock_object.unlock();
}
private:
/// Internal mutex to make sure the threads do not interfere with each other.
std::mutex lock_object;
};
#endif