blob: 5bea835e3411ec9443d70a0a0e84f42c72fc45a0 (
plain)
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
#ifndef VDR_LIVE_RECORDINGS_H
#define VDR_LIVE_RECORDINGS_H
#include <ctime>
#include <map>
#include <vector>
#include <boost/shared_ptr.hpp>
#include <vdr/recording.h>
namespace vdrlive {
class RecordingsManager;
typedef boost::shared_ptr<RecordingsManager> RecordingsManagerPtr;
class RecordingsManager
{
friend RecordingsManagerPtr LiveRecordingsManager();
public:
/**
* generates a Md5 hash from a cRecording entry. It can be used
* to reidentify a recording.
*/
std::string Md5Hash(const cRecording* recording) const;
/**
* fetches a cRecording from VDR's Recordings collection. Returns
* NULL if recording was not found
*/
const cRecording* GetByMd5Hash(const std::string& hash) const;
private:
RecordingsManager();
cThreadLock m_recordingsLock;
};
class RecordingsTree
{
public:
class RecordingsItem;
typedef boost::shared_ptr< RecordingsItem > RecordingsItemPtr;
typedef std::multimap< std::string, RecordingsItemPtr > Map;
class RecordingsItem
{
friend class RecordingsTree;
public:
virtual ~RecordingsItem();
virtual time_t StartTime() const = 0;
virtual bool IsDir() const = 0;
virtual const std::string& Name() const { return m_name; }
virtual const std::string Id() const = 0;
virtual const cRecording* Recording() const { return 0; }
virtual const cRecordingInfo* RecInfo() const { return 0; }
protected:
RecordingsItem(const std::string& name);
private:
std::string m_name;
Map m_entries;
};
class RecordingsItemDir : public RecordingsItem
{
public:
RecordingsItemDir();
RecordingsItemDir(const std::string& name, int level);
virtual ~RecordingsItemDir();
virtual time_t StartTime() const { return 0; }
virtual bool IsDir() const { return true; }
virtual const std::string Id() const { std::string e; return e; }
private:
int m_level;
};
class RecordingsItemRec : public RecordingsItem
{
public:
RecordingsItemRec(const std::string& id, const std::string& name, cRecording* recording);
virtual ~RecordingsItemRec();
virtual time_t StartTime() const;
virtual bool IsDir() const { return false; }
virtual const std::string Id() const { return m_id; }
virtual const cRecording* Recording() const { return m_recording; }
virtual const cRecordingInfo* RecInfo() const { return m_recording->Info(); }
private:
cRecording *m_recording;
std::string m_id;
};
RecordingsTree(RecordingsManagerPtr recManPtr);
virtual ~RecordingsTree();
Map::iterator begin(const std::vector< std::string >& path);
Map::iterator end(const std::vector< std::string >&path);
int MaxLevel() const { return m_maxLevel; }
private:
int m_maxLevel;
RecordingsItemPtr m_root;
RecordingsManagerPtr m_recManPtr;
Map::iterator findDir(RecordingsItemPtr& dir, const std::string& dirname);
};
/**
* return singleton instance of RecordingsManager as a shared Pointer.
* This ensures that after last use of the RecordingsManager it is
* deleted. After deletion of the original RecordingsManager a repeated
* call to this function creates a new RecordingsManager which is again
* kept alive as long references to it exist.
*/
RecordingsManagerPtr LiveRecordingsManager();
} // namespace vdrlive
#endif // VDR_LIVE_RECORDINGS_H
|
