utils.h

Go to the documentation of this file.

/*
        Aseba - an event-based framework for distributed robot control
        Copyright (C) 2007--2012:
                Stephane Magnenat <stephane at magnenat dot net>
                (http://stephane.magnenat.net)
                and other contributors, see authors.txt for details
        
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU Lesser General Public License as published
        by the Free Software Foundation, version 3 of the License.
        
        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU Lesser General Public License for more details.
        
        You should have received a copy of the GNU Lesser General Public License
        along with this program. If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef ASEBA_UTILS_H
#define ASEBA_UTILS_H

#include <iostream>
#include <string>
#include <cassert>
#include <cstdlib>
#include "../common/types.h"

namespace Aseba
{
        
        template<typename Derived, typename Base>
        static inline Derived polymorphic_downcast(Base base)
        {
                Derived derived = dynamic_cast<Derived>(base);
                if (!derived)
                        abort();
                return derived;
        }
        
        template<typename Derived, typename Base>
        static inline Derived polymorphic_downcast_or_null(Base base)
        {
                if (!base)
                        return 0;
                Derived derived = dynamic_cast<Derived>(base);
                if (!derived)
                        abort();
                return derived;
        }
        
        struct UnifiedTime
        {
                typedef long long unsigned Value;
                Value value;
                
                UnifiedTime();
                UnifiedTime(Value ms);
                UnifiedTime(Value seconds, Value milliseconds);
                
                void operator +=(const UnifiedTime &that) { value += that.value; }
                void operator -=(const UnifiedTime &that) { value -= that.value; }
                void operator /=(const long long unsigned factor) {  assert(factor); value /= factor; }
                void operator *=(const long long unsigned factor) { value *= factor; }
                UnifiedTime operator +(const UnifiedTime &that) const { return UnifiedTime(value + that.value); }
                UnifiedTime operator -(const UnifiedTime &that) const { return UnifiedTime(value - that.value); }
                UnifiedTime operator /(const long long unsigned factor) const { assert(factor); return UnifiedTime(value / factor); }
                UnifiedTime operator *(const long long unsigned factor) const { return UnifiedTime(value * factor); }
                bool operator <(const UnifiedTime &that) const { return value < that.value; }
                
                void sleep() const;
                
                std::string toHumanReadableStringFromEpoch() const;
                
                std::string toRawTimeString() const;
                
                static UnifiedTime fromRawTimeString(const std::string& rawTimeString);
        };
        
        void dumpTime(std::ostream &stream, bool raw = false);
        
        std::string WStringToUTF8(const std::wstring& s);
        
        std::wstring UTF8ToWString(const std::string& s);
        
        uint16 crcXModem(const uint16 oldCrc, const std::wstring& s);
        
        uint16 crcXModem(const uint16 oldCrc, const uint16 v);
        
};

#endif