Mercurial > hg > orthanc

comparison Core/Toolbox.cpp @ 759:8cfc6119a5bd dicom-rt

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
integration mainline -> dicom-rt
author Sebastien Jodogne <s.jodogne@gmail.com>
date Wed, 16 Apr 2014 16:04:55 +0200
parents b82292ba2083 203157cb4fde
children e57e08ed510f
comparison
equal deleted inserted replaced
605:b82292ba2083 759:8cfc6119a5bd
1 /** 1 /**
2 * Orthanc - A Lightweight, RESTful DICOM Store 2 * Orthanc - A Lightweight, RESTful DICOM Store
3 * Copyright (C) 2012-2013 Medical Physics Department, CHU of Liege, 3 * Copyright (C) 2012-2014 Medical Physics Department, CHU of Liege,
4 * Belgium 4 * Belgium
5 * 5 *
6 * This program is free software: you can redistribute it and/or 6 * This program is free software: you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License as 7 * modify it under the terms of the GNU General Public License as
8 * published by the Free Software Foundation, either version 3 of the 8 * published by the Free Software Foundation, either version 3 of the
40 #include <boost/filesystem/fstream.hpp> 40 #include <boost/filesystem/fstream.hpp>
41 #include <boost/date_time/posix_time/posix_time.hpp> 41 #include <boost/date_time/posix_time/posix_time.hpp>
42 #include <boost/uuid/sha1.hpp> 42 #include <boost/uuid/sha1.hpp>
43 #include <algorithm> 43 #include <algorithm>
44 #include <ctype.h> 44 #include <ctype.h>
45 #include <boost/regex.hpp>
45 46
46 #if defined(_WIN32) 47 #if defined(_WIN32)
47 #include <windows.h> 48 #include <windows.h>
48 #endif 49 #endif
49 50
154 { 155 {
155 finish = true; 156 finish = true;
156 } 157 }
157 #endif 158 #endif
158 159
159 void Toolbox::Sleep(uint32_t seconds)
160 {
161 #if defined(_WIN32)
162 ::Sleep(static_cast<DWORD>(seconds) * static_cast<DWORD>(1000));
163 #elif defined(__linux)
164 usleep(static_cast<uint64_t>(seconds) * static_cast<uint64_t>(1000000));
165 #else
166 #error Support your platform here
167 #endif
168 }
169
170 void Toolbox::USleep(uint64_t microSeconds) 160 void Toolbox::USleep(uint64_t microSeconds)
171 { 161 {
172 #if defined(_WIN32) 162 #if defined(_WIN32)
173 ::Sleep(static_cast<DWORD>(microSeconds / static_cast<uint64_t>(1000))); 163 ::Sleep(static_cast<DWORD>(microSeconds / static_cast<uint64_t>(1000)));
174 #elif defined(__linux) 164 #elif defined(__linux)
184 #if defined(_WIN32) 174 #if defined(_WIN32)
185 SetConsoleCtrlHandler(ConsoleControlHandler, true); 175 SetConsoleCtrlHandler(ConsoleControlHandler, true);
186 #else 176 #else
187 signal(SIGINT, SignalHandler); 177 signal(SIGINT, SignalHandler);
188 signal(SIGQUIT, SignalHandler); 178 signal(SIGQUIT, SignalHandler);
179 signal(SIGTERM, SignalHandler);
189 #endif 180 #endif
190 181
191 finish = false; 182 finish = false;
192 while (!finish) 183 while (!finish)
193 { 184 {
197 #if defined(_WIN32) 188 #if defined(_WIN32)
198 SetConsoleCtrlHandler(ConsoleControlHandler, false); 189 SetConsoleCtrlHandler(ConsoleControlHandler, false);
199 #else 190 #else
200 signal(SIGINT, NULL); 191 signal(SIGINT, NULL);
201 signal(SIGQUIT, NULL); 192 signal(SIGQUIT, NULL);
193 signal(SIGTERM, NULL);
202 #endif 194 #endif
203 } 195 }
204 196
205 197
206 198
213 void Toolbox::ToLowerCase(std::string& s) 205 void Toolbox::ToLowerCase(std::string& s)
214 { 206 {
215 std::transform(s.begin(), s.end(), s.begin(), tolower); 207 std::transform(s.begin(), s.end(), s.begin(), tolower);
216 } 208 }
217 209
210
211 void Toolbox::ToUpperCase(std::string& result,
212 const std::string& source)
213 {
214 result = source;
215 ToUpperCase(result);
216 }
217
218 void Toolbox::ToLowerCase(std::string& result,
219 const std::string& source)
220 {
221 result = source;
222 ToLowerCase(result);
223 }
218 224
219 225
220 void Toolbox::ReadFile(std::string& content, 226 void Toolbox::ReadFile(std::string& content,
221 const std::string& path) 227 const std::string& path)
222 { 228 {
446 452
447 453
448 void Toolbox::ComputeMD5(std::string& result, 454 void Toolbox::ComputeMD5(std::string& result,
449 const std::string& data) 455 const std::string& data)
450 { 456 {
457 if (data.size() > 0)
458 {
459 ComputeMD5(result, &data[0], data.size());
460 }
461 else
462 {
463 ComputeMD5(result, NULL, 0);
464 }
465 }
466
467
468 void Toolbox::ComputeMD5(std::string& result,
469 const void* data,
470 size_t length)
471 {
451 md5_state_s state; 472 md5_state_s state;
452 md5_init(&state); 473 md5_init(&state);
453 474
454 if (data.size() > 0) 475 if (length > 0)
455 { 476 {
456 md5_append(&state, reinterpret_cast<const md5_byte_t*>(&data[0]), 477 md5_append(&state,
457 static_cast<int>(data.size())); 478 reinterpret_cast<const md5_byte_t*>(data),
479 static_cast<int>(length));
458 } 480 }
459 481
460 md5_byte_t actualHash[16]; 482 md5_byte_t actualHash[16];
461 md5_finish(&state, actualHash); 483 md5_finish(&state, actualHash);
462 484
726 throw OrthancException(ErrorCode_NotImplemented); 748 throw OrthancException(ErrorCode_NotImplemented);
727 } 749 }
728 } 750 }
729 751
730 752
731 753 std::string Toolbox::WildcardToRegularExpression(const std::string& source)
732 void Toolbox::Split(std::vector<std::string>& result, 754 {
733 const std::string& source, 755 // TODO - Speed up this with a regular expression
734 char delimiter) 756
735 { 757 std::string result = source;
736 if (source.size() == 0) 758
737 { 759 // Escape all special characters
738 result.clear(); 760 boost::replace_all(result, "\\", "\\\\");
739 return; 761 boost::replace_all(result, "^", "\\^");
740 } 762 boost::replace_all(result, ".", "\\.");
741 763 boost::replace_all(result, "$", "\\$");
742 size_t count = 1; 764 boost::replace_all(result, "|", "\\|");
743 for (size_t i = 0; i < source.size(); i++) 765 boost::replace_all(result, "(", "\\(");
744 { 766 boost::replace_all(result, ")", "\\)");
745 if (source[i] == delimiter) 767 boost::replace_all(result, "[", "\\[");
746 { 768 boost::replace_all(result, "]", "\\]");
747 count++; 769 boost::replace_all(result, "+", "\\+");
748 } 770 boost::replace_all(result, "/", "\\/");
749 } 771 boost::replace_all(result, "{", "\\{");
750 772 boost::replace_all(result, "}", "\\}");
773
774 // Convert wildcards '*' and '?' to their regex equivalents
775 boost::replace_all(result, "?", ".");
776 boost::replace_all(result, "*", ".*");
777
778 return result;
779 }
780
781
782
783 void Toolbox::TokenizeString(std::vector<std::string>& result,
784 const std::string& value,
785 char separator)
786 {
751 result.clear(); 787 result.clear();
752 result.resize(count); 788
753 789 std::string currentItem;
754 size_t pos = 0; 790
755 size_t start = 0; 791 for (size_t i = 0; i < value.size(); i++)
756 while (start < source.size()) 792 {
757 { 793 if (value[i] == separator)
758 assert(pos < count); 794 {
759 795 result.push_back(currentItem);
760 size_t end = start; 796 currentItem.clear();
761 while (end < source.size() && 797 }
762 source[end] != delimiter) 798 else
763 { 799 {
764 end++; 800 currentItem.push_back(value[i]);
765 } 801 }
766 802 }
767 result[pos++] = source.substr(start, end - start); 803
768 start = end + 1; 804 result.push_back(currentItem);
769 } 805 }
770 }
771
772 } 806 }
807