+# define SWIFTEN_API

+# define SWIFTEN_API

+ cls(const cls&) = default;

+ cls& operator=(const cls&) = default;

+ /*

+ * Generic erase()

+ */

+ namespace Detail {

+ struct VectorCategory {};

+ struct ListCategory {};

+ struct MapCategory {};

+

+ template<typename T>

+ struct ContainerTraits;

+

+ template<typename A, typename B>

+ struct ContainerTraits< std::vector<A, B> > {

+ typedef VectorCategory Category;

+ };

+

+ template<>

+ struct ContainerTraits< std::string > {

+ typedef VectorCategory Category;

+ };

+

+ template<typename A, typename B>

+ struct ContainerTraits< std::list<A, B> > {

+ typedef ListCategory Category;

+ };

+

+ template<typename A, typename B, typename C, typename D>

+ struct ContainerTraits< std::map<A, B, C, D> > {

+ typedef MapCategory Category;

+ };

+

+ template<typename C, typename V>

+ void eraseImpl(C& c, const V& v, VectorCategory) {

+ c.erase(std::remove(c.begin(), c.end(), v), c.end());

+ }

+

+ template<typename C, typename V>

+ void eraseImpl(C& c, const V& v, ListCategory) {

+ c.remove(v);

+ }

+

+ template<typename C, typename V>

+ void eraseImpl(C& c, const V& v, MapCategory) {

+ for (typename C::iterator it = c.begin(); it != c.end(); ) {

+ if (it->second == v) {

+ c.erase(it++);

+ }

+ else {

+ ++it;

+ }

+ }

+ }

+

+ template<typename C, typename P>

+ void eraseIfImpl(C& c, const P& p, MapCategory) {

+ for (typename C::iterator it = c.begin(); it != c.end(); ) {

+ if (p(*it)) {

+ c.erase(it++);

+ }

+ else {

+ ++it;

+ }

+ }

+ }

+

+ template<typename C, typename P>

+ void eraseIfImpl(C& c, const P& p, VectorCategory) {

+ c.erase(std::remove_if(c.begin(), c.end(), p), c.end());

+ }

+ }

+

+ template<typename C, typename V>

+ void erase(C& container, const V& value) {

+ Detail::eraseImpl(container, value, typename Detail::ContainerTraits<C>::Category());

+ }

+

+ template<typename C, typename P>

+ void eraseIf(C& container, const P& predicate) {

+ Detail::eraseIfImpl(container, predicate, typename Detail::ContainerTraits<C>::Category());

+ }

+

+ template<typename Source, typename Target>

+ void append(Target& target, const Source& source) {

+ target.insert(target.end(), source.begin(), source.end());

+ }

+

+ template<typename Source, typename Target>

+ void assign(Target& target, const Source& source) {

+ target.assign(source.begin(), source.end());

+ }

+

+ template<typename A, typename B, typename C, typename D>

+ B get(const std::map<A, B, C, D>& map, const A& key, const B& defaultValue) {

+ typename std::map<A, B, C, D>::const_iterator i = map.find(key);

+ if (i != map.end()) {

+ return i->second;

+ }

+ else {

+ return defaultValue;

+ }

+ }

+

+ template<typename Container>

+ void safeClear(Container& c) {

+ std::fill(c.begin(), c.end(), 0);

+ c.clear();

+ }

+

+ /*

+ * Functors

+ */

+ template<typename K, typename V>

+ class PairFirstEquals {

+ public:

+ PairFirstEquals(const K& value) : value(value) {

+ }

+

+ bool operator()(const std::pair<K,V>& pair) const {

+ return pair.first == value;

+ }

+

+ private:

+ K value;

+ };

+

+ template<typename K, typename V>

+ class PairSecondEquals {

+ public:

+ PairSecondEquals(const V& value) : value(value) {

+ }

+

+ bool operator()(const std::pair<K,V>& pair) const {

+ return pair.second == value;

+ }

+

+ private:

+ V value;

+ };

+ * This class template provides a read/write access synchronized wrapper for other types.

+ public:

+ Atomic(const ValueType& v) : value_(v) {

+ }

+

+ /**

+ * Synchronized write access.

+ */

+ Atomic<ValueType>& operator=(const ValueType& newValue) {

+ boost::lock_guard<boost::mutex> lock(valueMutex_);

+ value_ = newValue;

+ return *this;

+ }

+

+ /**

+ * Synchronized read access.

+ */

+ operator ValueType() {

+ boost::lock_guard<boost::mutex> lock(valueMutex_);

+ return value_;

+ }

+

+ private:

+ boost::mutex valueMutex_;

+ ValueType value_;

+ // FIXME: Not a good seed

+ generator.seed(static_cast<unsigned int>(std::time(0)));

+ boost::uniform_int<> distribution(0, maximum);

+ return distribution(generator);

+ class SWIFTEN_API BoostRandomGenerator : public RandomGenerator {

+ public:

+ BoostRandomGenerator();

+ int generateRandomInteger(int max) SWIFTEN_OVERRIDE;

+ private:

+ boost::mt19937 generator;

+ };

+ boost::filesystem::ifstream input(file, std::ios_base::in|std::ios_base::binary);

+ while (input.good()) {

+ size_t oldSize = data.size();

+ data.resize(oldSize + BUFFER_SIZE);

+ input.read(reinterpret_cast<char*>(&data[oldSize]), BUFFER_SIZE);

+ data.resize(oldSize + boost::numeric_cast<size_t>(input.gcount()));

+ }

+ input.close();

+ return std::vector<unsigned char>(s.begin(), s.end());

+ std::vector<unsigned char> data;

+ while (*c) {

+ data.push_back(static_cast<unsigned char>(*c));

+ ++c;

+ }

+ return data;

+ size_t i;

+ for (i = b.size(); i > 0; --i) {

+ if (b[i - 1] != 0) {

+ break;

+ }

+ }

+ return i > 0 ? std::string(reinterpret_cast<const char*>(vecptr(b)), i) : "";

+ typedef std::vector<unsigned char> ByteArray;

+ SWIFTEN_API ByteArray createByteArray(const std::string& s);

+ SWIFTEN_API ByteArray createByteArray(const char* c);

+ inline ByteArray createByteArray(const unsigned char* c, size_t n) {

+ return ByteArray(c, c + n);

+ }

+ inline ByteArray createByteArray(const char* c, size_t n) {

+ return ByteArray(c, c + n);

+ }

+ inline ByteArray createByteArray(char c) {

+ return std::vector<unsigned char>(1, static_cast<unsigned char>(c));

+ }

+ template<typename T, typename A>

+ static const T* vecptr(const std::vector<T, A>& v) {

+ return v.empty() ? NULL : &v[0];

+ }

+ template<typename T, typename A>

+ static T* vecptr(std::vector<T, A>& v) {

+ return v.empty() ? NULL : &v[0];

+ }

+ SWIFTEN_API std::string byteArrayToString(const ByteArray& b);

+

+ SWIFTEN_API void readByteArrayFromFile(ByteArray&, const boost::filesystem::path& file);

+ template<typename C>

+ C concat(const C& c1, const C& c2) {

+ C result;

+ result.resize(c1.size() + c2.size());

+ std::copy(c2.begin(), c2.end(), std::copy(c1.begin(), c1.end(), result.begin()));

+ return result;

+ }

+ template<typename C>

+ C concat(const C& c1, const C& c2, const C& c3) {

+ C result;

+ result.resize(c1.size() + c2.size() + c3.size());

+ std::copy(c3.begin(), c3.end(), std::copy(c2.begin(), c2.end(), std::copy(c1.begin(), c1.end(), result.begin())));

+ return result;

+ }

+ template<typename C>

+ C concat(const C& c1, const C& c2, const C& c3, const C& c4) {

+ C result;

+ result.resize(c1.size() + c2.size() + c3.size() + c4.size());

+ std::copy(c4.begin(), c4.end(), std::copy(c3.begin(), c3.end(), std::copy(c2.begin(), c2.end(), std::copy(c1.begin(), c1.end(), result.begin()))));

+ return result;

+ }

+ template<typename C>

+ C concat(const C& c1, const C& c2, const C& c3, const C& c4, const C& c5) {

+ C result;

+ result.resize(c1.size() + c2.size() + c3.size() + c4.size() + c5.size());

+ std::copy(c5.begin(), c5.end(), std::copy(c4.begin(), c4.end(), std::copy(c3.begin(), c3.end(), std::copy(c2.begin(), c2.end(), std::copy(c1.begin(), c1.end(), result.begin())))));

+ return result;

+ }

+ template<typename C>

+ C concat(const C& c1, const C& c2, const C& c3, const C& c4, const C& c5, const C& c6) {

+ C result;

+ result.resize(c1.size() + c2.size() + c3.size() + c4.size() + c5.size() + c6.size());

+ std::copy(c6.begin(), c6.end(), std::copy(c5.begin(), c5.end(), std::copy(c4.begin(), c4.end(), std::copy(c3.begin(), c3.end(), std::copy(c2.begin(), c2.end(), std::copy(c1.begin(), c1.end(), result.begin()))))));

+ return result;

+ }

+ template<typename C>

+ C concat(const C& c1, const C& c2, const C& c3, const C& c4, const C& c5, const C& c6, const C& c7) {

+ C result;

+ result.resize(c1.size() + c2.size() + c3.size() + c4.size() + c5.size() + c6.size() + c7.size());

+ std::copy(c7.begin(), c7.end(), std::copy(c6.begin(), c6.end(), std::copy(c5.begin(), c5.end(), std::copy(c4.begin(), c4.end(), std::copy(c3.begin(), c3.end(), std::copy(c2.begin(), c2.end(), std::copy(c1.begin(), c1.end(), result.begin())))))));

+ return result;

+ }

+ template<typename C>

+ C concat(const C& c1, const C& c2, const C& c3, const C& c4, const C& c5, const C& c6, const C& c7, const C& c8) {

+ C result;

+ result.resize(c1.size() + c2.size() + c3.size() + c4.size() + c5.size() + c6.size() + c7.size() + c8.size());

+ std::copy(c8.begin(), c8.end(), std::copy(c7.begin(), c7.end(), std::copy(c6.begin(), c6.end(), std::copy(c5.begin(), c5.end(), std::copy(c4.begin(), c4.end(), std::copy(c3.begin(), c3.end(), std::copy(c2.begin(), c2.end(), std::copy(c1.begin(), c1.end(), result.begin()))))))));

+ return result;

+ }

+ template<typename C>

+ C concat(const C& c1, const C& c2, const C& c3, const C& c4, const C& c5, const C& c6, const C& c7, const C& c8, const C& c9) {

+ C result;

+ result.resize(c1.size() + c2.size() + c3.size() + c4.size() + c5.size() + c6.size() + c7.size() + c8.size() + c9.size());

+ std::copy(c9.begin(), c9.end(), std::copy(c8.begin(), c8.end(), std::copy(c7.begin(), c7.end(), std::copy(c6.begin(), c6.end(), std::copy(c5.begin(), c5.end(), std::copy(c4.begin(), c4.end(), std::copy(c3.begin(), c3.end(), std::copy(c2.begin(), c2.end(), std::copy(c1.begin(), c1.end(), result.begin())))))))));

+ return result;

+ }

+ static std::locale locale(std::locale::classic(), new boost::local_time::local_time_input_facet("%Y-%m-%d %H:%M:%S%F%ZP"));

+ std::istringstream stream(string);

+ stream.imbue(locale);

+ boost::local_time::local_date_time result(boost::date_time::not_a_date_time);

+ stream >> result;

+ return result.utc_time();

+ std::string stampString = std::string(boost::posix_time::to_iso_extended_string(time));

+ String::replaceAll(stampString, ',', ".");

+ stampString += "Z";

+ return stampString;

+ std::string localString;

+ try {

+ localString = boost::posix_time::to_simple_string(boost::date_time::c_local_adjustor<boost::posix_time::ptime>::utc_to_local(time));

+ }

+ catch(std::out_of_range& exception) {

+ SWIFT_LOG(debug) << exception.what() << std::endl;

+ }

+ return localString;

+ /**

+ * Converts a date formatted according to XEP-0082 into a ptime

+ * object (in UTC).

+ */

+ SWIFTEN_API boost::posix_time::ptime stringToDateTime(const std::string& string);

+ /**

+ * Converts a UTC ptime object to a XEP-0082 formatted string.

+ */

+ SWIFTEN_API std::string dateTimeToString(const boost::posix_time::ptime& time);

+ /**

+ * Converts a UTC ptime object to a localized human readable string.

+ */

+ SWIFTEN_API std::string dateTimeToLocalString(const boost::posix_time::ptime& time);

+ os << "ClientError(";

+ switch(error.getType()) {

+ case Swift::ClientError::UnknownError:

+ os << "UnknownError";

+ break;

+ case Swift::ClientError::DomainNameResolveError:

+ os << "DomainNameResolveError";

+ break;

+ case Swift::ClientError::ConnectionError:

+ os << "ConnectionError";

+ break;

+ case Swift::ClientError::ConnectionReadError:

+ os << "ConnectionReadError";

+ break;

+ case Swift::ClientError::ConnectionWriteError:

+ os << "ConnectionWriteError";

+ break;

+ case Swift::ClientError::XMLError:

+ os << "XMLError";

+ break;

+ case Swift::ClientError::AuthenticationFailedError:

+ os << "AuthenticationFailedError";

+ break;

+ case Swift::ClientError::CompressionFailedError:

+ os << "CompressionFailedError";

+ break;

+ case Swift::ClientError::ServerVerificationFailedError:

+ os << "ServerVerificationFailedError";

+ break;

+ case Swift::ClientError::NoSupportedAuthMechanismsError:

+ os << "NoSupportedAuthMechanismsError";

+ break;

+ case Swift::ClientError::UnexpectedElementError:

+ os << "UnexpectedElementError";

+ break;

+ case Swift::ClientError::ResourceBindError:

+ os << "ResourceBindError";

+ break;

+ case Swift::ClientError::SessionStartError:

+ os << "SessionStartError";

+ break;

+ case Swift::ClientError::StreamError:

+ os << "StreamError";

+ break;

+ case Swift::ClientError::TLSError:

+ os << "TLSError";

+ break;

+ case Swift::ClientError::ClientCertificateLoadError:

+ os << "ClientCertificateLoadError";

+ break;

+ case Swift::ClientError::ClientCertificateError:

+ os << "ClientCertificateError";

+ break;

+ case Swift::ClientError::CertificateCardRemoved:

+ os << "CertificateCardRemoved";

+ break;

+ case Swift::ClientError::UnknownCertificateError:

+ os << "UnknownCertificateError";

+ break;

+ case Swift::ClientError::CertificateExpiredError:

+ os << "CertificateExpiredError";

+ break;

+ case Swift::ClientError::CertificateNotYetValidError:

+ os << "CertificateNotYetValidError";

+ break;

+ case Swift::ClientError::CertificateSelfSignedError:

+ os << "CertificateSelfSignedError";

+ break;

+ case Swift::ClientError::CertificateRejectedError:

+ os << "CertificateRejectedError";

+ break;

+ case Swift::ClientError::CertificateUntrustedError:

+ os << "CertificateUntrustedError";

+ break;

+ case Swift::ClientError::InvalidCertificatePurposeError:

+ os << "InvalidCertificatePurposeError";

+ break;

+ case Swift::ClientError::CertificatePathLengthExceededError:

+ os << "CertificatePathLengthExceededError";

+ break;

+ case Swift::ClientError::InvalidCertificateSignatureError:

+ os << "InvalidCertificateSignatureError";

+ break;

+ case Swift::ClientError::InvalidCAError:

+ os << "InvalidCAError";

+ break;

+ case Swift::ClientError::InvalidServerIdentityError:

+ os << "InvalidServerIdentityError";

+ break;

+ case Swift::ClientError::RevokedError:

+ os << "RevokedError";

+ break;

+ case Swift::ClientError::RevocationCheckFailedError:

+ os << "RevocationCheckFailedError";

+ break;

+ }

+ os << ")";

+ return os;

+ using namespace Swift;

+ boost::shared_ptr<Element> element = boost::shared_ptr<Element>(ele);

+ boost::shared_ptr<Payload> payload = boost::dynamic_pointer_cast<Payload>(element);

+ if (payload) {

+ FullPayloadSerializerCollection payloadSerializerCollection;

+ PayloadSerializer *serializer = payloadSerializerCollection.getPayloadSerializer(payload);

+ os << "Payload(" << serializer->serialize(payload) << ")";

+ return os;

+ }

+ boost::shared_ptr<ToplevelElement> topLevelElement = boost::dynamic_pointer_cast<ToplevelElement>(element);

+ if (topLevelElement) {

+ FullPayloadSerializerCollection payloadSerializerCollection;

+ XMPPSerializer xmppSerializer(&payloadSerializerCollection, ClientStreamType, false);

+ SafeByteArray serialized = xmppSerializer.serializeElement(topLevelElement);

+ os << "TopLevelElement(" << safeByteArrayToString(serialized) << ")";

+ return os;

+ }

+ os << "Element(Unknown)";

+ return os;

+ class ClientError;

+ class Element;

+ template<class T> class shared_ptr;

+ class SWIFTEN_API Error {

+ public:

+ Error() {}

+ SWIFTEN_DEFAULT_COPY_CONSTRUCTOR(Error)

+ virtual ~Error();

+ };

+ static const char *siPrefix[] = {"k", "M", "G", "T", "P", "E", "Z", "Y", NULL};

+ int power = 0;

+ double engBytes = bytes;

+ while (engBytes >= 1000) {

+ ++power;

+ engBytes = engBytes / 1000.0;

+ }

+ return str( boost::format("%.1lf %sB") % engBytes % (power > 0 ? siPrefix[power-1] : "") );

+ static boost::uuids::random_generator generator;

+ return boost::lexical_cast<std::string>(generator());

+ class SWIFTEN_API IDGenerator {

+ public:

+ IDGenerator();

+ std::string generateID();

+ };

+ template<typename T>

+ class SWIFTEN_API Listenable {

+ public:

+ void addListener(T* listener) {

+ listeners.push_back(listener);

+ }

+

+ void removeListener(T* listener) {

+ listeners.erase(std::remove(listeners.begin(), listeners.end(), listener), listeners.end());

+ }

+

+ protected:

+ template<typename F>

+ void notifyListeners(F event) {

+ for (typename std::vector<T*>::iterator i = listeners.begin(); i != listeners.end(); ++i) {

+ event(*i);

+ }

+ }

+

+ template<typename F, typename A1>

+ void notifyListeners(F f, const A1& a1) {

+ notifyListeners(boost::bind(f, _1, a1));

+ }

+

+ template<typename F, typename A1, typename A2>

+ void notifyListeners(F f, const A1& a1, const A2& a2) {

+ notifyListeners(boost::bind(f, _1, a1, a2));

+ }

+

+ template<typename F, typename A1, typename A2, typename A3>

+ void notifyListeners(F f, const A1& a1, const A2& a2, const A3& a3) {

+ notifyListeners(boost::bind(f, _1, a1, a2, a3));

+ }

+

+ private:

+ std::vector<T*> listeners;

+ };

+ __android_log_print(ANDROID_LOG_VERBOSE, "Swift", stream.str().c_str(), 1);

+ // Using stdio for thread safety (POSIX file i/o calls are guaranteed to be atomic)

+ fprintf(stderr, "%s", stream.str().c_str());

+ fflush(stderr);

+ Severity /*severity*/,

+ const std::string& severityString,

+ const std::string& file,

+ int line,

+ const std::string& function) {

+ stream << "[" << severityString << "] " << file << ":" << line << " " << function << ": ";

+ return stream;

+ return logLevel;

+ logLevel = level;

+ class SWIFTEN_API Log {

+ public:

+ enum Severity {

+ error, warning, info, debug

+ };

+

+ Log();

+ ~Log();

+

+ std::ostringstream& getStream(

+ Severity severity,

+ const std::string& severityString,

+ const std::string& file,

+ int line,

+ const std::string& function);

+

+ static Severity getLogLevel();

+ static void setLogLevel(Severity level);

+

+ private:

+ std::ostringstream stream;

+ };

+ if (Log::severity > Log::getLogLevel()) ; \

+ else Log().getStream(Log::severity, #severity, __FILE__, __LINE__, __FUNCTION__)

+ if (Log::severity > Log::getLogLevel() || (test)) ; \

+ else Log().getStream(Log::severity, #severity, __FILE__, __LINE__, __FUNCTION__) << "Assertion failed: " << #test << ". "

+ return boost::filesystem::path(convertStringToWString(path));

+ return boost::filesystem::path(path);

+ return convertWStringToString(path.native());

+ return path.native();

+ /**

+ * Creates a path for the given UTF-8 encoded string.

+ * This works independently of global locale settings.

+ */

+ SWIFTEN_API boost::filesystem::path stringToPath(const std::string&);

+

+ /**

+ * Returns the UTF-8 representation of the given path

+ * This works independently of global locale settings.

+ */

+ SWIFTEN_API std::string pathToString(const boost::filesystem::path&);

+ ByteArray path;

+ uint32_t size = 4096;

+ path.resize(size);

+ if (_NSGetExecutablePath(const_cast<char*>(reinterpret_cast<const char*>(vecptr(path))), &size) == 0) {

+ return boost::filesystem::path(std::string(reinterpret_cast<const char*>(vecptr(path)), path.size()).c_str()).parent_path();

+ }

+ ByteArray path;

+ path.resize(4096);

+ size_t size = static_cast<size_t>(readlink("/proc/self/exe", reinterpret_cast<char*>(vecptr(path)), path.size()));

+ if (size > 0) {

+ path.resize(size);

+ return boost::filesystem::path(std::string(reinterpret_cast<const char*>(vecptr(path)), path.size()).c_str()).parent_path();

+ }

+ std::vector<wchar_t> data;

+ data.resize(2048);

+ GetModuleFileNameW(NULL, vecptr(data), data.size());

+ return boost::filesystem::path(

+ std::wstring(vecptr(data), data.size())).parent_path();

+ return boost::filesystem::path();

+ class SWIFTEN_API Paths {

+ public:

+ static boost::filesystem::path getExecutablePath();

+ };

+ class SWIFTEN_API RandomGenerator {

+ public:

+ virtual ~RandomGenerator();

+ /**

+ * Generates a random integer between 0 and 'max',

+ * 'max' inclusive.

+ */

+ virtual int generateRandomInteger(int max) = 0;

+ };

+ namespace Regex {

+ std::string escape(const std::string& source) {

+ // escape regex special characters: ^.$| etc

+ // these need to be escaped: [\^\$\|.........]

+ // and then C++ requires '\' to be escaped, too....

+ static const boost::regex esc("([\\^\\.\\$\\|\\(\\)\\[\\]\\*\\+\\?\\/\\{\\}\\\\])");

+ // matched character should be prepended with '\'

+ // replace matched special character with \\\1

+ // and escape once more for C++ rules...

+ static const std::string rep("\\\\\\1");

+ return boost::regex_replace(source, esc, rep);

+ }

+

+ }

+

+ namespace Regex {

+ SWIFTEN_API std::string escape(const std::string& source);

+ }

+ SecureZeroMemory(memory, numberOfBytes);

+ volatile char* p = memory;

+ for (size_t i = 0; i < numberOfBytes; ++i) {

+ *(p++) = 0;

+ }

+ void secureZeroMemory(char* memory, size_t numberOfBytes);

+

+ template<typename T>

+ class SWIFTEN_API SafeAllocator : public std::allocator<T> {

+ public:

+ template <class U> struct rebind {

+ typedef SafeAllocator<U> other;

+ };

+

+ SafeAllocator() SWIFTEN_NOEXCEPT {}

+ SafeAllocator(const SafeAllocator&) SWIFTEN_NOEXCEPT : std::allocator<T>() {}

+ template <class U> SafeAllocator(const SafeAllocator<U>&) SWIFTEN_NOEXCEPT {}

+ ~SafeAllocator() SWIFTEN_NOEXCEPT {}

+

+ void deallocate (T* p, size_t num) {

+ secureZeroMemory(reinterpret_cast<char*>(p), num);

+ std::allocator<T>::deallocate(p, num);

+ }

+

+ SWIFTEN_DEFAULT_COPY_ASSIGMNENT_OPERATOR(SafeAllocator)

+ };

+ SafeByteArray data;

+ while (*c) {

+ data.push_back(static_cast<unsigned char>(*c));

+ ++c;

+ }

+ return data;

+ typedef std::vector<unsigned char, SafeAllocator<unsigned char> > SafeByteArray;

+ inline SafeByteArray createSafeByteArray(const ByteArray& a) {

+ return SafeByteArray(a.begin(), a.end());

+ }

+ SWIFTEN_API SafeByteArray createSafeByteArray(const char* c);

+ inline SafeByteArray createSafeByteArray(const std::string& s) {

+ return SafeByteArray(s.begin(), s.end());

+ }

+ inline boost::shared_ptr<SafeByteArray> createSafeByteArrayRef(const std::string& s) {

+ return boost::make_shared<SafeByteArray>(s.begin(), s.end());

+ }

+ inline SafeByteArray createSafeByteArray(char c) {

+ return SafeByteArray(1, static_cast<unsigned char>(c));

+ }

+ inline SafeByteArray createSafeByteArray(const char* c, size_t n) {

+ return SafeByteArray(c, c + n);

+ }

+ inline boost::shared_ptr<SafeByteArray> createSafeByteArrayRef(const char* c, size_t n) {

+ return boost::make_shared<SafeByteArray>(c, c + n);

+ }

+ inline SafeByteArray createSafeByteArray(const unsigned char* c, size_t n) {

+ return SafeByteArray(c, c + n);

+ }

+ inline boost::shared_ptr<SafeByteArray> createSafeByteArrayRef(const unsigned char* c, size_t n) {

+ return boost::make_shared<SafeByteArray>(c, c + n);

+ }

+ /* WARNING! This breaks the safety of the data in the safe byte array.

+ * Do not use in modes that require data safety. */

+ inline std::string safeByteArrayToString(const SafeByteArray& b) {

+ return byteArrayToString(ByteArray(b.begin(), b.end()));

+ }

+ class SWIFTEN_API SafeString {

+ public:

+ SafeString(const SafeByteArray& data) : data(data) {

+ }

+ SafeString(const std::string& s) {

+ data = createSafeByteArray(s);

+ }

+ SafeString(const char* s) {

+ data = createSafeByteArray(s);

+ }

+ operator SafeByteArray () const {

+ return data;

+ }

+ private:

+ SafeByteArray data;

+ };

+ bool carry = true;

+ size_t i = 0;

+ while (carry && i < currentID.size()) {

+ char c = currentID[i];

+ if (c >= 'z') {

+ currentID[i] = 'a';

+ }

+ else {

+ currentID[i] = c+1;

+ carry = false;

+ }

+ ++i;

+ }

+ if (carry) {

+ currentID += 'a';

+ }

+ return currentID;

+ /**

+ * @brief The SimpleIDGenerator class implements a IDGenerator generating consecutive ID strings from

+ * the lower case latin alphabet.

+ */

+ class SWIFTEN_API SimpleIDGenerator : public IDGenerator {

+ public:

+ SimpleIDGenerator();

+ std::string generateID();

+ private:

+ std::string currentID;

+ };

+ template<typename T> class StartStopper {

+ public:

+ StartStopper(T* target) : target(target) {

+ target->start();

+ }

+ ~StartStopper() {

+ target->stop();

+ }

+

+ private:

+ T* target;

+ };

+ if ((firstByte & 0x80) == 0) {

+ return 1;

+ }

+ if ((firstByte & 0xE0) == 0xC0) {

+ return 2;

+ }

+ if ((firstByte & 0xF0) == 0xE0) {

+ return 3;

+ }

+ if ((firstByte & 0xF8) == 0xF0) {

+ return 4;

+ }

+ if ((firstByte & 0xFC) == 0xF8) {

+ return 5;

+ }

+ if ((firstByte & 0xFE) == 0xFC) {

+ return 6;

+ }

+ assert(false);

+ return 1;

+ std::vector<unsigned int> result;

+ for (size_t i = 0; i < s.size();) {

+ unsigned int codePoint = 0;

+ char firstChar = s[i];

+ size_t length = sequenceLength(firstChar);

+

+ // First character is special

+ size_t firstCharBitSize = 7 - length;

+ if (length == 1) {

+ firstCharBitSize = 7;

+ }

+ codePoint = firstChar & ((1<<(firstCharBitSize+1)) - 1);

+

+ for (size_t j = 1; j < length; ++j) {

+ codePoint = (codePoint<<6) | (s[i+j] & 0x3F);

+ }

+ result.push_back(codePoint);

+ i += length;

+ }

+ return result;

+ assert((c & 0x80) == 0);

+ size_t firstMatch = s.find(c);

+ if (firstMatch != s.npos) {

+ return std::make_pair(s.substr(0,firstMatch),s.substr(firstMatch+1,s.npos));

+ }

+ else {

+ return std::make_pair(s, "");

+ }

+ size_t lastPos = 0;

+ size_t matchingIndex = 0;

+ while ((matchingIndex = src.find(c, lastPos)) != src.npos) {

+ src.replace(matchingIndex, 1, s);

+ lastPos = matchingIndex + s.size();

+ }

+ assert((c & 0x80) == 0);

+ std::vector<std::string> result;

+ std::string accumulator;

+ for (size_t i = 0; i < s.size(); ++i) {

+ if (s[i] == c) {

+ result.push_back(accumulator);

+ accumulator = "";

+ }

+ else {

+ accumulator += s[i];

+ }

+ }

+ result.push_back(accumulator);

+ return result;

+ std::stringstream ss;

+ ss << std::setbase(16);

+ ss << h;

+ return ss.str();

+ std::stringstream ss;

+ int h;

+ ss << std::setbase(16);

+ ss << s;

+ ss >> h;

+ return h;

+ int utf8Size = WideCharToMultiByte(CP_UTF8, 0, s.c_str(), -1, NULL, 0, NULL, NULL);

+ if (utf8Size < 0) {

+ throw std::runtime_error("Conversion error");

+ }

+ std::vector<char> utf8Data(utf8Size);

+ int result = WideCharToMultiByte(

+ CP_UTF8, 0, s.c_str(), -1, vecptr(utf8Data), utf8Data.size(), NULL, NULL);

+ if (result < 0) {

+ throw std::runtime_error("Conversion error");

+ }

+ return std::string(vecptr(utf8Data), utf8Size-1 /* trailing 0 character */);

+ int utf16Size = MultiByteToWideChar(CP_UTF8, 0, s.c_str(), -1, NULL, 0);

+ if (utf16Size < 0) {

+ throw std::runtime_error("Conversion error");

+ }

+ std::vector<wchar_t> utf16Data(utf16Size);

+ int result = MultiByteToWideChar(

+ CP_UTF8, 0, s.c_str(), -1, vecptr(utf16Data), utf16Data.size());

+ if (result < 0) {

+ throw std::runtime_error("Conversion error");

+ }

+ return std::wstring(vecptr(utf16Data), utf16Size-1 /* trailing 0 character */);

+ CFStringCreateWithBytes(NULL, reinterpret_cast<const UInt8*>(a.c_str()), a.size(), kCFStringEncodingUTF8, false)

+ namespace String {

+ SWIFTEN_API std::vector<unsigned int> getUnicodeCodePoints(const std::string&);

+ SWIFTEN_API std::pair<std::string, std::string> getSplittedAtFirst(const std::string&, char c);

+ SWIFTEN_API std::vector<std::string> split(const std::string&, char c);

+ SWIFTEN_API void replaceAll(std::string&, char c, const std::string& s);

+ inline bool beginsWith(const std::string& s, char c) {

+ return s.size() > 0 && s[0] == c;

+ }

+ inline bool endsWith(const std::string& s, char c) {

+ return s.size() > 0 && s[s.size()-1] == c;

+ }

+ std::string convertIntToHexString(int h);

+ int convertHexStringToInt(const std::string& s);

+ }

+ SWIFTEN_API std::string convertWStringToString(const std::wstring& s);

+ SWIFTEN_API std::wstring convertStringToWString(const std::string& s);

+ class SWIFTEN_API makeString {

+ public:

+ template <typename T> makeString& operator<<(T const& v) {

+ stream << v;

+ return *this;

+ }

+ operator std::string() const {

+ return stream.str();

+ }

+ private:

+ std::ostringstream stream;

+ };

+ if (url.getPort()) {

+ return *url.getPort();

+ }

+ else if (url.getScheme() == "http") {

+ return 80;

+ }

+ else if (url.getScheme() == "https") {

+ return 443;

+ }

+ else {

+ std::cerr << "Unknown scheme: " + url.getScheme() << std::endl;

+ return 80;

+ }

+ size_t colonIndex = urlString.find(':');

+ if (colonIndex == std::string::npos) {

+ return URL();

+ }

+ std::string scheme = urlString.substr(0, colonIndex);

+ // Authority

+ if (urlString.size() > colonIndex + 2 && urlString[colonIndex+1] == '/' && urlString[colonIndex+2] == '/') {

+ size_t authorityIndex = colonIndex + 3;

+ size_t slashIndex = urlString.find('/', authorityIndex);

+ std::string authority;

+ std::string path;

+ if (slashIndex == std::string::npos) {

+ authority = urlString.substr(authorityIndex);

+ path = "";

+ }

+ else {

+ authority = urlString.substr(authorityIndex, slashIndex - authorityIndex);

+ path = unescape(urlString.substr(slashIndex));

+ }

+ size_t atIndex = authority.find('@');

+ std::string userInfo;

+ std::string hostAndPort;

+ if (atIndex != std::string::npos) {

+ userInfo = authority.substr(0, atIndex);

+ hostAndPort = authority.substr(atIndex + 1);

+ }

+ else {

+ userInfo = "";

+ hostAndPort = authority;

+ }

+ std::string host;

+ boost::optional<int> port;

+ colonIndex = hostAndPort.find(':');

+ if (colonIndex != std::string::npos) {

+ host = unescape(hostAndPort.substr(0, colonIndex));

+ try {

+ port = boost::lexical_cast<int>(hostAndPort.substr(colonIndex + 1));

+ }

+ catch (const boost::bad_lexical_cast&) {

+ return URL();

+ }

+ }

+ else {

+ host = unescape(hostAndPort);

+ }

+ if (port) {

+ return URL(scheme, host, *port, path);

+ }

+ else {

+ return URL(scheme, host, path);

+ }

+ }

+ else {

+ // We don't support URLs without authorities yet

+ return URL();

+ }

+ if (empty) {

+ return "";

+ }

+ std::string result = scheme + "://";

+ if (!user.empty()) {

+ result += user;

+ if (!password.empty()) {

+ result += ":" + password;

+ }

+ result += "@";

+ }

+ result += host;

+ if (port) {

+ result += ":";

+ result += boost::lexical_cast<std::string>(*port);

+ }

+ result += path;

+ return result;

+ boost::iterator_range<Iterator> r = boost::first_finder("%")(begin, end);

+ if (r.end() == end) {

+ return r;

+ }

+ else {

+ if (r.end() + 1 == end || r.end() + 2 == end) {

+ throw std::runtime_error("Incomplete escape character");

+ }

+ else {

+ r.advance_end(2);

+ return r;

+ }

+ }

+ std::stringstream s;

+ s << std::hex << std::string(match.begin() + 1, match.end());

+ unsigned int value;

+ s >> value;

+ if (s.fail() || s.bad()) {

+ throw std::runtime_error("Invalid escape character");

+ }

+ unsigned char charValue = static_cast<unsigned char>(value);

+ return std::string(reinterpret_cast<const char*>(&charValue), 1);

+ try {

+ return boost::find_format_all_copy(s, PercentEncodedCharacterFinder(), PercentUnencodeFormatter());

+ }

+ catch (const std::exception&) {

+ return "";

+ }

+ std::string result;

+ for (size_t i = 0; i < str.size(); ++i) {

+ if (str[i] == '%') {

+ if (i + 3 < str.size()) {

+ std::stringstream s;

+ s << std::hex << str.substr(i+1, 2);

+ unsigned int value;

+ s >> value;

+ if (s.fail() || s.bad()) {

+ return "";

+ }

+ unsigned char charValue = static_cast<unsigned char>(value);

+ result += std::string(reinterpret_cast<const char*>(&charValue), 1);

+ i += 2;

+ }

+ else {

+ return "";

+ }

+ }

+ else {

+ result += str[i];

+ }

+ }

+ return result;

+ public:

+

+ URL() : scheme(""), user(""), password(""), host(""), path(""), empty(true) {

+ }

+

+ URL(const std::string& scheme, const std::string& host, int port, const std::string& path) : scheme(scheme), user(), password(), host(host), port(port), path(path), empty(false) {

+ }

+

+ URL(const std::string& scheme, const std::string& host, const std::string& path) : scheme(scheme), user(), password(), host(host), path(path), empty(false) {

+ }

+

+ /**

+ * Whether the URL is empty.

+ */

+ bool isEmpty() const {

+ return empty;

+ }

+

+ /**

+ * Scheme used for the URL (http, https etc.)

+ */

+ const std::string& getScheme() const {

+ return scheme;

+ }

+

+ /**

+ * Hostname

+ */

+ const std::string& getHost() const {

+ return host;

+ }

+

+ /**

+ * Port number

+ */

+ boost::optional<int> getPort() const {

+ return port;

+ }

+

+ /**

+ * Path

+ */

+ const std::string& getPath() const {

+ return path;

+ }

+

+ std::string toString() const;

+

+ static int getPortOrDefaultPort(const URL& url);

+ static URL fromString(const std::string&);

+ static std::string unescape(const std::string&);

+

+

+ private:

+ std::string scheme;

+ std::string user;

+ std::string password;

+ std::string host;

+ boost::optional<int> port;

+ std::string path;

+ bool empty;

+ };

+ CPPUNIT_TEST_SUITE(ByteArrayTest);

+ CPPUNIT_TEST(testGetData_NoData);

+ CPPUNIT_TEST(testToString);

+ CPPUNIT_TEST(testToString_NullTerminated);

+ CPPUNIT_TEST(testToString_TwoNullTerminated);

+ CPPUNIT_TEST(testToString_AllNull);

+ CPPUNIT_TEST_SUITE_END();

+ public:

+ void testGetData_NoData() {

+ ByteArray testling;

+ CPPUNIT_ASSERT_EQUAL(reinterpret_cast<const char*>(NULL), reinterpret_cast<const char*>(vecptr(testling)));

+ }

+ void testToString() {

+ ByteArray testling(createByteArray("abcde"));

+ CPPUNIT_ASSERT_EQUAL(std::string("abcde"), byteArrayToString(testling));

+ }

+ void testToString_NullTerminated() {

+ ByteArray testling(createByteArray("abcde\0", 6));

+ CPPUNIT_ASSERT_EQUAL(std::string("abcde"), byteArrayToString(testling));

+ }

+ void testToString_TwoNullTerminated() {

+ ByteArray testling(createByteArray("abcde\0\0", 7));

+ CPPUNIT_ASSERT_EQUAL(std::string("abcde"), byteArrayToString(testling));

+ }

+ void testToString_AllNull() {

+ ByteArray testling(createByteArray("\0\0", 2));

+ CPPUNIT_ASSERT_EQUAL(std::string(""), byteArrayToString(testling));

+ }

+ CPPUNIT_TEST_SUITE(DateTimeTest);

+ CPPUNIT_TEST(testStringToDateTime_UTC);

+ CPPUNIT_TEST(testStringToDateTime_WithTimezone);

+ CPPUNIT_TEST(testDateTimeToString);

+ CPPUNIT_TEST(testDateTimeToLocalStringNotThrowingException);

+ CPPUNIT_TEST_SUITE_END();

+ public:

+ void testStringToDateTime_UTC() {

+ boost::posix_time::ptime time = stringToDateTime("1969-07-21T02:56:15Z");

+ CPPUNIT_ASSERT_EQUAL(std::string("1969-07-21T02:56:15"), boost::posix_time::to_iso_extended_string(time));

+ }

+ void testStringToDateTime_WithTimezone() {

+ boost::posix_time::ptime time = stringToDateTime("1969-07-20T21:56:15-05:00");

+ CPPUNIT_ASSERT_EQUAL(std::string("1969-07-21T02:56:15"), boost::posix_time::to_iso_extended_string(time));

+ }

+ void testDateTimeToString() {

+ boost::posix_time::ptime time = stringToDateTime("1969-07-20T21:56:15-05:00");

+ CPPUNIT_ASSERT_EQUAL(std::string("1969-07-21T02:56:15Z"), dateTimeToString(time));

+ }

+ void testDateTimeToLocalStringNotThrowingException() {

+ boost::posix_time::ptime time = stringToDateTime("1954-07-20T21:56:15-05:00");

+ CPPUNIT_ASSERT_EQUAL(std::string(""), dateTimeToLocalString(time));

+ }

+ CPPUNIT_TEST_SUITE(IDGeneratorTest);

+ CPPUNIT_TEST(testGenerate);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ IDGeneratorTest() {}

+

+ void setUp() {

+ generatedIDs_.clear();

+ }

+

+ void testGenerate() {

+ IDGenerator testling;

+ for (unsigned int i = 0; i < 26*4; ++i) {

+ std::string id = testling.generateID();

+ CPPUNIT_ASSERT(generatedIDs_.insert(id).second);

+ }

+ }

+

+ private:

+ std::set<std::string> generatedIDs_;

+ CPPUNIT_TEST_SUITE(PathTest);

+ CPPUNIT_TEST(testStringToPath);

+ CPPUNIT_TEST(testPathToString);

+ CPPUNIT_TEST_SUITE_END();

+ public:

+ void testStringToPath() {

+ CPPUNIT_ASSERT(std::wstring(L"tron\xe7on") == stringToPath("tron\xc3\xa7on").native());

+ CPPUNIT_ASSERT_EQUAL(std::string("tron\xc3\xa7on"), stringToPath("tron\xc3\xa7on").native());

+ }

+ void testPathToString() {

+ CPPUNIT_ASSERT_EQUAL(std::string("tron\xc3\xa7on"), pathToString(stringToPath("tron\xc3\xa7on")));

+ }

+ CPPUNIT_TEST_SUITE(SimpleIDGeneratorTest);

+ CPPUNIT_TEST(testGenerate);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ SimpleIDGeneratorTest() {}

+

+ void setUp() {

+ generatedIDs_.clear();

+ }

+

+ void testGenerate() {

+ SimpleIDGenerator testling;

+ for (unsigned int i = 0; i < 26*4; ++i) {

+ std::string id = testling.generateID();

+ CPPUNIT_ASSERT(generatedIDs_.insert(id).second);

+ }

+ }

+

+ private:

+ std::set<std::string> generatedIDs_;

+ CPPUNIT_TEST_SUITE(StringTest);

+ CPPUNIT_TEST(testGetUnicodeCodePoints);

+ CPPUNIT_TEST(testGetSplittedAtFirst);

+ CPPUNIT_TEST(testGetSplittedAtFirst_CharacterAtBegin);

+ CPPUNIT_TEST(testGetSplittedAtFirst_CharacterAtEnd);

+ CPPUNIT_TEST(testGetSplittedAtFirst_NoSuchCharacter);

+ CPPUNIT_TEST(testReplaceAll);

+ CPPUNIT_TEST(testReplaceAll_LastChar);

+ CPPUNIT_TEST(testReplaceAll_ConsecutiveChars);

+ CPPUNIT_TEST(testReplaceAll_MatchingReplace);

+ CPPUNIT_TEST(testSplit);

+ CPPUNIT_TEST(testConvertWStringToString);

+ CPPUNIT_TEST(testConvertStringToWString);

+ CPPUNIT_TEST_SUITE_END();

+ public:

+ void testGetUnicodeCodePoints() {

+ std::string testling("$\xc2\xa2\xe2\x82\xac\xf4\x8a\xaf\x8d");

+ std::vector<unsigned int> points = String::getUnicodeCodePoints(testling);

+ CPPUNIT_ASSERT_EQUAL(0x24U, points[0]);

+ CPPUNIT_ASSERT_EQUAL(0xA2U, points[1]);

+ CPPUNIT_ASSERT_EQUAL(0x20ACU, points[2]);

+ CPPUNIT_ASSERT_EQUAL(0x10ABCDU, points[3]);

+ }

+ void testGetSplittedAtFirst() {

+ std::string testling("ab@cd@ef");

+ std::pair<std::string,std::string> result = String::getSplittedAtFirst(testling, '@');

+ CPPUNIT_ASSERT_EQUAL(std::string("ab"), result.first);

+ CPPUNIT_ASSERT_EQUAL(std::string("cd@ef"), result.second);

+ }

+ void testGetSplittedAtFirst_CharacterAtBegin() {

+ std::string testling(" ab");

+ std::pair<std::string,std::string> result = String::getSplittedAtFirst(testling, ' ');

+ CPPUNIT_ASSERT(result.first.empty());

+ CPPUNIT_ASSERT_EQUAL(std::string("ab"), result.second);

+ }

+ void testGetSplittedAtFirst_CharacterAtEnd() {

+ std::string testling("ab@");

+ std::pair<std::string,std::string> result = String::getSplittedAtFirst(testling, '@');

+ CPPUNIT_ASSERT_EQUAL(std::string("ab"), result.first);

+ CPPUNIT_ASSERT(result.second.empty());

+ }

+ void testGetSplittedAtFirst_NoSuchCharacter() {

+ std::string testling("ab");

+ std::pair<std::string,std::string> result = String::getSplittedAtFirst(testling, '@');

+ CPPUNIT_ASSERT_EQUAL(std::string("ab"), result.first);

+ CPPUNIT_ASSERT(result.second.empty());

+ }

+ void testReplaceAll() {

+ std::string testling("abcbd");

+ String::replaceAll(testling, 'b', "xyz");

+ CPPUNIT_ASSERT_EQUAL(std::string("axyzcxyzd"), testling);

+ }

+ void testReplaceAll_LastChar() {

+ std::string testling("abc");

+ String::replaceAll(testling, 'c', "xyz");

+ CPPUNIT_ASSERT_EQUAL(std::string("abxyz"), testling);

+ }

+ void testReplaceAll_ConsecutiveChars() {

+ std::string testling("abbc");

+ String::replaceAll(testling, 'b',"xyz");

+ CPPUNIT_ASSERT_EQUAL(std::string("axyzxyzc"), testling);

+ }

+ void testReplaceAll_MatchingReplace() {

+ std::string testling("abc");

+

+ String::replaceAll(testling, 'b',"bbb");

+

+ CPPUNIT_ASSERT_EQUAL(std::string("abbbc"), testling);

+ }

+

+ void testSplit() {

+ std::vector<std::string> result = String::split("abc def ghi", ' ');

+

+ CPPUNIT_ASSERT_EQUAL(3, static_cast<int>(result.size()));

+ CPPUNIT_ASSERT_EQUAL(std::string("abc"), result[0]);

+ CPPUNIT_ASSERT_EQUAL(std::string("def"), result[1]);

+ CPPUNIT_ASSERT_EQUAL(std::string("ghi"), result[2]);

+ }

+ void testConvertWStringToString() {

+ CPPUNIT_ASSERT_EQUAL(std::string("tron\xc3\xa7on"), convertWStringToString(std::wstring(L"tron\xe7on")));

+ }

+ void testConvertStringToWString() {

+ CPPUNIT_ASSERT(std::wstring(L"tron\xe7on") == convertStringToWString(std::string("tron\xc3\xa7on")));

+ }

+ CPPUNIT_TEST_SUITE(URLTest);

+ CPPUNIT_TEST(testFromString);

+ CPPUNIT_TEST(testFromString_WithoutPath);

+ CPPUNIT_TEST(testFromString_WithRootPath);

+ CPPUNIT_TEST(testFromString_WithPort);

+ CPPUNIT_TEST(testFromString_WithPortOnePartPath);

+ CPPUNIT_TEST(testFromString_WithPortWithoutPath);

+ CPPUNIT_TEST(testFromString_WithUserInfo);

+ CPPUNIT_TEST(testFromString_NonASCIIHost);

+ CPPUNIT_TEST(testFromString_NonASCIIPath);

+ CPPUNIT_TEST(testToString);

+ CPPUNIT_TEST(testToString_WithPort);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void testFromString() {

+ URL url = URL::fromString("http://foo.bar/baz/bam");

+

+ CPPUNIT_ASSERT_EQUAL(std::string("http"), url.getScheme());

+ CPPUNIT_ASSERT_EQUAL(std::string("foo.bar"), url.getHost());

+ CPPUNIT_ASSERT(!url.getPort());

+ CPPUNIT_ASSERT_EQUAL(std::string("/baz/bam"), url.getPath());

+ }

+

+ void testFromString_WithoutPath() {

+ URL url = URL::fromString("http://foo.bar");

+

+ CPPUNIT_ASSERT_EQUAL(std::string("http"), url.getScheme());

+ CPPUNIT_ASSERT_EQUAL(std::string("foo.bar"), url.getHost());

+ CPPUNIT_ASSERT(!url.getPort());

+ CPPUNIT_ASSERT_EQUAL(std::string(""), url.getPath());

+ }

+

+ void testFromString_WithRootPath() {

+ URL url = URL::fromString("http://foo.bar/");

+

+ CPPUNIT_ASSERT_EQUAL(std::string("http"), url.getScheme());

+ CPPUNIT_ASSERT_EQUAL(std::string("foo.bar"), url.getHost());

+ CPPUNIT_ASSERT(!url.getPort());

+ CPPUNIT_ASSERT_EQUAL(std::string("/"), url.getPath());

+ }

+

+ void testFromString_WithPort() {

+ URL url = URL::fromString("http://foo.bar:1234/baz/bam");

+

+ CPPUNIT_ASSERT_EQUAL(std::string("http"), url.getScheme());

+ CPPUNIT_ASSERT_EQUAL(std::string("foo.bar"), url.getHost());

+ CPPUNIT_ASSERT_EQUAL(1234, *url.getPort());

+ CPPUNIT_ASSERT_EQUAL(std::string("/baz/bam"), url.getPath());

+ }

+

+ void testFromString_WithPortOnePartPath() {

+ URL url = URL::fromString("http://foo.bar:11440/http-bind/");

+

+ CPPUNIT_ASSERT_EQUAL(std::string("http"), url.getScheme());

+ CPPUNIT_ASSERT_EQUAL(std::string("foo.bar"), url.getHost());

+ CPPUNIT_ASSERT_EQUAL(11440, *url.getPort());

+ CPPUNIT_ASSERT_EQUAL(std::string("/http-bind/"), url.getPath());

+ }

+

+ void testFromString_WithPortWithoutPath() {

+ URL url = URL::fromString("http://foo.bar:1234");

+

+ CPPUNIT_ASSERT_EQUAL(std::string("http"), url.getScheme());

+ CPPUNIT_ASSERT_EQUAL(std::string("foo.bar"), url.getHost());

+ CPPUNIT_ASSERT_EQUAL(1234, *url.getPort());

+ CPPUNIT_ASSERT_EQUAL(std::string(""), url.getPath());

+ }

+

+ void testFromString_WithUserInfo() {

+ URL url = URL::fromString("http://user:pass@foo.bar/baz/bam");

+

+ CPPUNIT_ASSERT_EQUAL(std::string("http"), url.getScheme());

+ CPPUNIT_ASSERT_EQUAL(std::string("foo.bar"), url.getHost());

+ CPPUNIT_ASSERT_EQUAL(std::string("/baz/bam"), url.getPath());

+ }

+

+ void testFromString_NonASCIIHost() {

+ URL url = URL::fromString("http://www.tron%C3%A7on.be/baz/bam");

+

+ CPPUNIT_ASSERT_EQUAL(std::string("www.tron\xc3\xa7on.be"), url.getHost());

+ }

+

+ void testFromString_NonASCIIPath() {

+ URL url = URL::fromString("http://foo.bar/baz/tron%C3%A7on/bam");

+

+ CPPUNIT_ASSERT_EQUAL(std::string("/baz/tron\xc3\xa7on/bam"), url.getPath());

+ }

+

+ void testToString() {

+ CPPUNIT_ASSERT_EQUAL(std::string("http://foo.bar/baz/bam"), URL("http", "foo.bar", "/baz/bam").toString());

+ }

+

+ void testToString_WithPort() {

+ CPPUNIT_ASSERT_EQUAL(std::string("http://foo.bar:1234/baz/bam"), URL("http", "foo.bar", 1234, "/baz/bam").toString());

+ }

+ class WindowsRegistry {

+ public:

+ static bool isFIPSEnabled() {

+ char* pathForXP = "System\\CurrentControlSet\\Control\\Lsa";

+ char* pathSinceVista = "System\\CurrentControlSet\\Control\\Lsa\\FIPSAlgorithmPolicy";

+ char* keyForXP = "FIPSAlgorithmPolicy";

+ char* keySinceVista = "Enabled";

+

+ OSVERSIONINFO osvi;

+ ZeroMemory(&osvi, sizeof(OSVERSIONINFO));

+ osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);

+ GetVersionEx(&osvi);

+

+ char* keyForOS = osvi.dwMajorVersion < 6 ? keyForXP : keySinceVista;

+ char* pathForOS = osvi.dwMajorVersion < 6 ? pathForXP : pathSinceVista;

+

+ /* http://support.microsoft.com/kb/811833 */

+ /* http://msdn.microsoft.com/en-us/library/ms724911%28VS.85%29.aspx */

+ HKEY key;

+ bool result = false;

+ if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,

+ pathForOS,

+ 0,

+ KEY_READ,

+ &key) != ERROR_SUCCESS) {

+ /* If we can't find the key that says we're FIPS, we're not FIPS */

+ return result;

+ }

+ DWORD keyType = REG_DWORD;

+ DWORD data;

+ DWORD length = sizeof(data);

+

+ if (RegQueryValueEx(key,

+ keyForOS,

+ NULL,

+ &keyType,

+ (LPBYTE)&data,

+ &length) == ERROR_SUCCESS) {

+ result = data != 0;

+ }

+

+ RegCloseKey(key);

+ return result;

+ }

+ };

+ namespace bsignals = signals;

+ inline boost::format format(const std::string& s) {

+ using namespace boost::io;

+ try {

+ boost::format fmter(s);

+ fmter.exceptions(no_error_bits);

+ return fmter;

+ }

+ catch (...) {

+ std::cerr << "Error: Invalid translation: " << s << std::endl;

+ throw;

+ }

+ }

+ boost::xtime xt;

+ boost::xtime_get(&xt, boost::TIME_UTC_);

+ boost::xtime_get(&xt, boost::TIME_UTC);

+ xt.nsec += msecs*1000000;

+ boost::thread::sleep(xt);

+ SWIFTEN_API void sleep(unsigned int msecs);