DayTime.cs
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
using System;
using Microsoft.SPOT;

namespace UAM.InformatiX.SPOT
{
/// <summary>
/// Reprezentuje denní čas v rozsahu 00:00 - 24:00 s přesností na milisekundy.
/// </summary>
[Serializable]
public struct DayTime : IComparable
{
/// <summary>
/// Nejmenší hodnota, jakou může <see cref="DayTime"/> mít, což je 00:00.000. Pouze pro čtení.
/// </summary>
public static readonly DayTime MinValue = new DayTime(0);
/// <summary>
/// Největší hodnota, jakou může <see cref="DayTime"/> mít, což je 23:59.999. Pouze pro čtení.
/// </summary>
public static readonly DayTime MaxValue = new DayTime(MillisPerDay - 1);
/// <summary>
/// Vrací aktuální systémový čas.
/// </summary>
public static DayTime Now { get { return (DayTime)DateTime.Now.TimeOfDay; } }

/// <summary>
/// Počet milisekund za den.
/// </summary>
public const int MillisPerDay = 86400000;
/// <summary>
/// Počet milisekund za vteřinu.
/// </summary>
public const int MillisPerSecond = 1000;
/// <summary>
/// Počet miliskund za minutu.
/// </summary>
public const int MillisPerMinute = 60000;
/// <summary>
/// Počet milisekund za hodinu.
/// </summary>
public const int MillisPerHour = 3600000;
/// <summary>
/// Počet ticků za milisekundu.
/// </summary>
public const int TicksPerMillisecond = 10000;

private int totalMilliseconds;
/// <summary>
/// Celkový počet milisekund od půlnoci.
/// </summary>
/// <returns>
/// Počet milisekund od půlnoci, který tato <see cref="DayTime"/> struktura představuje.
/// Může nabývat hodnot z rosahu 0-86399999;
/// </returns>
public int TotalMilliseconds
{
get { return totalMilliseconds; }
set
{
if (value >= 0) totalMilliseconds = value % MillisPerDay;
while (value < 0)
value += MillisPerDay;
totalMilliseconds = value;
}
}

/// <summary>
/// Vytvoření nové instance denního času na základě hodin, minut a vteřin.
/// </summary>
/// <param name="hour">Počet hodin, které má tato struktura reprezentovat.</param>
/// <param name="minute">Počet minut, které má tato struktura reprezentovat. Minuty přes jednu hodinu se započítají do hodin.</param>
/// <param name="second">Počet sekund, které má tato struktura reprezentaovat. Sekundy přes jednu minutu se započítají do minut.</param>
public DayTime(byte hour, byte minute, byte second)
{
totalMilliseconds = 0;
TotalMilliseconds = hour * MillisPerHour + minute * MillisPerMinute + second * MillisPerSecond;
}
/// <summary>
/// Vytvoření nové instance denního času na základě hodin a minut.
/// </summary>
/// <param name="hour">Počet hodin, které má tato struktura reprezentovat.</param>
/// <param name="minute">Počet minut, které má tato struktura reprezentovat. Minuty přes jednu hodinu se započítají do hodin.</param>
public DayTime(byte hour, byte minute)
{
totalMilliseconds = 0;
TotalMilliseconds = hour * MillisPerHour + minute * MillisPerMinute;
}
/// <summary>
/// Vytvoření nové instance denního času na základě milisekund.
/// </summary>
/// <param name="milliseconds">Počet milisekund od půlnoci, které má tato struktura reprezentovat.</param>
public DayTime(int milliseconds)
{
totalMilliseconds = 0;
TotalMilliseconds = milliseconds;
}

/// <summary>
/// Vrací nebo nastavuje počet celých hodin, které <see cref="DayTime"/> reprezentuje, v rozmezí 00-23.
/// Hodnoty mimo tento rozsah jsou přepočítány.
/// </summary>
/// <returns>
/// Hodinovou složku této <see cref="DayTime"/> struktury.
/// Může nabývat hodnot z rozsahu 0-23.
/// </returns>
public int Hour
{
get { return TotalMilliseconds / MillisPerHour; }
set { TotalMilliseconds -= (TotalMilliseconds / MillisPerHour - value) * MillisPerHour; }
}
/// <summary>
/// Počet celých minut, které <see cref="DayTime"/> reprezentuje, v rozmezí 00-59.
/// Ostatní složky jsou upraveny, pokud je hodnota mimo tento rozsah.
/// </summary>
/// <returns>
/// Minutovou složku této <see cref="DayTime"/> struktury.
/// Může nabývat hodnot z rozsahu 0-59.
/// </returns>
public int Minute
{
get { return (TotalMilliseconds % MillisPerHour) / MillisPerMinute; }
set
{
TotalMilliseconds =
(TotalMilliseconds % MillisPerMinute)
+ value * MillisPerMinute
+ (TotalMilliseconds / MillisPerHour) * MillisPerHour;

}
}
/// <summary>
/// Počet celých sekund, které <see cref="DayTime"/> reprezentuje, v rozmezí 0-59.
/// Ostatní složky jsou upraveny, pokud je hodnota mimo tento rozsah.
/// </summary>
/// <returns>
/// Vteřinovou složku této <see cref="DayTime"/> struktury.
/// Může nabývat hodnot z rozsahu 0-59.
/// </returns>
public int Second
{
get { return (TotalMilliseconds % MillisPerMinute) / MillisPerSecond; }
set
{
TotalMilliseconds =
(TotalMilliseconds % MillisPerSecond)
+ value * MillisPerSecond
+ (TotalMilliseconds / MillisPerMinute) * MillisPerMinute;
}
}
/// <summary>
/// Počet celých milisekund, které <see cref="DayTime"/> reprezentuje, v rozmezí 000-999.
/// Ostatní složky jsou upraveny, pokud je hodnota mimo tento rozsah.
/// </summary>
/// <returns>
/// Milisekundovou složku této <see cref="DayTime"/> struktury.
/// Může nabývat hodnot z rozsahu 0-999.
/// </returns>
public int Millisecond
{
get { return TotalMilliseconds % MillisPerSecond; }
set { TotalMilliseconds = (TotalMilliseconds / MillisPerSecond) * MillisPerSecond + value; }
}

/// <summary>
/// Posune čas o hodinu dopředu.
/// </summary>
public void AddHour() { TotalMilliseconds += MillisPerHour; }
/// <summary>
/// Posune čas o hodinu nazpět.
/// </summary>
public void SubtractHour() { TotalMilliseconds -= MillisPerHour; }
/// <summary>
/// Posune čas o minutu dopředu. Přičtení minuty zvýší hodinu, pokud počet minut překročí 59.
/// </summary>
public void AddMinute() { TotalMilliseconds += MillisPerMinute; }
/// <summary>
/// Posune čas o minutu nazpět. Odečení minuty sníží hodinu, pokud počet minut překročí 0.
/// </summary>
public void SubtractMinute() { TotalMilliseconds -= MillisPerMinute; }

/// <summary>
/// Vytvoří textovou reprezentaci této instance.
/// </summary>
/// <returns>Textovou reprezentaci této instance, ve formátu hh:mm:ss[.ff].</returns>
public override string ToString()
{
return TimeSpan.FromTicks((long)totalMilliseconds * TicksPerMillisecond).ToString();
}
/// <summary>
/// Vyhodnotí, zda je tato instance rovná určenému objektu.
/// </summary>
/// <param name="value">Objekt, jenž má být s touto instancí porovnán.</param>
/// <returns>true, pokud je value typu <see cref="DayTime"/> a představuje stejný časový údajjako tato instance; jinak false.</returns>
public override bool Equals(object value)
{
if (value is DayTime)
return totalMilliseconds == ((DayTime)value).totalMilliseconds;

return false;
}

/// <summary>
/// Vrátí hash této instance.
/// </summary>
/// <returns>32-bitová hodnota hashe.</returns>
public override int GetHashCode()
{
return totalMilliseconds.GetHashCode();
}
/// <summary>
/// Porovná dvě <see cref="DayTime"/> hodnoty a vrátí číslo popisující jejich vztah.
/// </summary>
/// <param name="t1"><see cref="DateTime"/> který se má porovnat.</param>
/// <param name="t2"><see cref="DateTime"/> který se má porovnat.</param>
/// <returns></returns>
public static int Compare(DayTime t1, DayTime t2)
{
if (t1.totalMilliseconds > t2.totalMilliseconds) return 1;
if (t1.totalMilliseconds < t2.totalMilliseconds) return -1;
return 0;
}
/// <summary>
/// Porovná tuto instanci s určeným objektem a vrátí číslo popisující jejich vztah.
/// </summary>
/// <param name="obj">Objekt k porovnání nebo null.</param>
/// <returns>-1 je-li hodnota této instance menší než hodnota porovnávaného objektu; 0 jsou-li hodnoty stejné; 1 je-li hodnota této instance větší než hodnota porovnávaného objektu, nebo je-li porovnávaný objekt null.</returns>
public int CompareTo(object obj)
{
if (obj == null) return 1;
return Compare(this, (DayTime)obj);
}

/// <summary>
/// Sečte dva denní časy <see cref="DayTime"/>.
/// </summary>
/// <param name="t1"><see cref="DayTime"/>.</param>
/// <param name="t2"><see cref="DayTime"/>.</param>
/// <returns></returns>
public static DayTime operator +(DayTime t1, DayTime t2) { return new DayTime(t1.totalMilliseconds + t2.totalMilliseconds); }
/// <summary>
/// Odečte jeden <see cref="DayTime"/> od druhého <see cref="DayTime"/>.
/// </summary>
/// <param name="t1"><see cref="DayTime"/>.</param>
/// <param name="t2"><see cref="DayTime"/>.</param>
/// <returns></returns>
public static DayTime operator -(DayTime t1, DayTime t2) { return new DayTime(t1.totalMilliseconds - t2.totalMilliseconds); }

/// <summary>
/// Rozhodne, zda dva <see cref="DayTime"/> reprezentují stejnou hodnotu.
/// </summary>
/// <param name="t1"><see cref="DayTime"/>.</param>
/// <param name="t2"><see cref="DayTime"/>.</param>
/// <returns>true pokud jsou si hodnoty rovny; jinak false.</returns>
public static bool operator ==(DayTime t1, DayTime t2) { return (t1.totalMilliseconds == t2.totalMilliseconds); }
/// <summary>
/// Rozhodne, zda dva <see cref="DayTime"/> reprezentují odlišnou hodnotu.
/// </summary>
/// <param name="t1"><see cref="DayTime"/>.</param>
/// <param name="t2"><see cref="DayTime"/>.</param>
/// <returns>true pokud si hodnoty nejsou rovny; jinak false.</returns>
public static bool operator !=(DayTime t1, DayTime t2) { return (t1.totalMilliseconds != t2.totalMilliseconds); }
/// <summary>
/// Rozhodne, zda je hodnota zadaného <see cref="DayTime"/> menší než jiného <see cref="DayTime"/>.
/// </summary>
/// <param name="t1"><see cref="DayTime"/>.</param>
/// <param name="t2"><see cref="DayTime"/>.</param>
/// <returns>true pokud hodnota t1 je menší než hodnota t2; jinak false.</returns>
public static bool operator < (DayTime t1, DayTime t2) { return (t1.totalMilliseconds < t2.totalMilliseconds); }
/// <summary>
/// Rozhodne, zda je hodnota zadaného <see cref="DayTime"/> rovna nebo menší než jiného <see cref="DayTime"/>.
/// </summary>
/// <param name="t1"><see cref="DayTime"/>.</param>
/// <param name="t2"><see cref="DayTime"/>.</param>
/// <returns>true pokud hodnota t1 je rovna nebo menší než hodnota t2; jinak false.</returns>
public static bool operator <=(DayTime t1, DayTime t2) { return (t1.totalMilliseconds <= t2.totalMilliseconds); }
/// <summary>
/// Rozhodne, zda je hodnota zadaného <see cref="DayTime"/> větší než jiného <see cref="DayTime"/>.
/// </summary>
/// <param name="t1"><see cref="DayTime"/>.</param>
/// <param name="t2"><see cref="DayTime"/>.</param>
/// <returns>true pokud hodnota t1 je větší než hodnota t2; jinak false.</returns>
public static bool operator > (DayTime t1, DayTime t2) { return (t1.totalMilliseconds > t2.totalMilliseconds); }
/// <summary>
/// Rozhodne, zda je hodnota zadaného <see cref="DayTime"/> rovna nebo větší než jiného <see cref="DayTime"/>.
/// </summary>
/// <param name="t1"><see cref="DayTime"/>.</param>
/// <param name="t2"><see cref="DayTime"/>.</param>
/// <returns>true pokud hodnota t1 je rovna nebo větší než hodnota t2; jinak false.</returns>
public static bool operator >=(DayTime t1, DayTime t2) { return (t1.totalMilliseconds >= t2.totalMilliseconds); }

/// <summary>
/// Převede strukturu <see cref="TimeSpan"/> na <see cref="DayTime"/> odpovídající hodnoty.
/// </summary>
/// <param name="t"><see cref="TimeSpan"/>, který se má převést.</param>
/// <returns><see cref="DayTime"/> s hodnotou nejbližší zadanému ´<see cref="TimeSpan"/>.</returns>
public static explicit operator DayTime(TimeSpan t) { return FromTimeSpan(t); }
/// <summary>
/// Převede strukturu <see cref="DayTime"/> na <see cref="TimeSpan"/> odpovídající hodnoty.
/// </summary>
/// <param name="d"><see cref="TimeSpan"/>, který se má převést.</param>
/// <returns><see cref="TimeSpan"/> se stejnou hodnotou.</returns>
public static implicit operator TimeSpan(DayTime d) { return TimeSpan.FromTicks((long)d.totalMilliseconds * TicksPerMillisecond); }

/// <summary>
/// Vytvoří <see cref="DayTime"/> odpovídající hodnotě <see cref="TimeSpan"/> s přesností na milisekundy.
/// </summary>
/// <param name="t"><see cref="DayTime"/>, jehož počet milisekund se použije.</param>
/// <returns><see cref="DayTime"/> s odpovídající hodnotou.</returns>
public static DayTime FromTimeSpan(TimeSpan t)
{
return new DayTime((int)(t.Ticks / TicksPerMillisecond));
}
}
}