CRNData.h

Go to the documentation of this file.

/* Copyright 2009-2016 INSA Lyon, Université Paris-Descartes, ENS-Lyon
 * 
 * This file is part of libcrn.
 * 
 * libcrn 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, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * libcrn 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 libcrn.  If not, see <http://www.gnu.org/licenses/>.
 * 
 * file: CRNData.h
 * \author Yann LEYDIER
 */

#ifndef CRNData_HEADER
#define CRNData_HEADER

#include <vector>
#include <CRNData/CRNInt.h>
#include <CRNData/CRNReal.h>
#include <CRNString.h>
#include <CRNStringUTF8.h>
#include <CRNIO/CRNPath.h>
#include <memory>
#include <CRNException.h>
#include <CRNMath/CRNProp3.h>
#include <cstring>

namespace crn
{
    namespace Data
    {
        UInt ToCRN(int i);
        UReal ToCRN(double d);
        UString ToCRN(const String &str);
        UStringUTF8 ToCRN(const StringUTF8 &str);
        UPath ToCRN(const Path &str);
        UProp3 ToCRN(const Prop3 &val);

        template<typename T> inline SObject ToCRN(std::shared_ptr<T> ptr)
        {
            SObject obj(std::dynamic_pointer_cast<Object>(ptr));
            if (!obj)
                throw ExceptionInvalidArgument("ToCRN(std::shared_ptr<T>): not a crn::Object.");
            return obj;
        }

        template<typename T> inline UObject ToCRN(const T* ptr)
        {
            return Clone(*ptr);
        }

        template<typename T> inline UObject ToCRN(const T &obj)
        {
            return Clone(obj);
        }
        template<typename T> inline T Convert(const Object &obj)
        {
            throw ExceptionInvalidArgument("T Convert(const Object &obj): no way to convert object to T.");
        }
        template<> inline int Convert(const Object &obj)
        {
            const Int *i = dynamic_cast<const Int*>(&obj);
            if (i)
                return int(*i);
            const String *s = dynamic_cast<const String*>(&obj);
            if (s)
                return s->ToInt();
            const StringUTF8 *su = dynamic_cast<const StringUTF8*>(&obj);
            if (su) // works for StringUTF8 and Path
                return su->ToInt();
            throw ExceptionInvalidArgument("Cannot convert between these types.");
        }
        template<> inline unsigned int Convert(const Object &obj)
        {
            const String *s = dynamic_cast<const String*>(&obj);
            if (s)
                return s->ToUInt();
            const StringUTF8 *su = dynamic_cast<const StringUTF8*>(&obj);
            if (su) // works for StringUTF8 and Path
                return su->ToUInt();
            throw ExceptionInvalidArgument("Cannot convert between these types.");
        }
        template<> inline double Convert(const Object &obj)
        {
            const Int *i = dynamic_cast<const Int*>(&obj);
            if (i)
                return int(*i);
            const Real *r = dynamic_cast<const Real*>(&obj);
            if (r)
                return *r;
            const String *s = dynamic_cast<const String*>(&obj);
            if (s)
                return s->ToDouble();
            const StringUTF8 *su = dynamic_cast<const StringUTF8*>(&obj);
            if (su) // works for StringUTF8 and Path
                return su->ToDouble();
            throw ExceptionInvalidArgument("Cannot convert between these types.");
        }
        template<> inline String Convert(const Object &obj)
        {
            const Int *i = dynamic_cast<const Int*>(&obj);
            if (i)
                return int(*i);
            const Real *r = dynamic_cast<const Real*>(&obj);
            if (r)
                return double(*r);
            const String *s = dynamic_cast<const String*>(&obj);
            if (s)
                return *s;
            const StringUTF8 *su = dynamic_cast<const StringUTF8*>(&obj);
            if (su) // works for StringUTF8 and Path
                return *su;
            throw ExceptionInvalidArgument("Cannot convert between these types.");
        }
        template<> inline StringUTF8 Convert(const Object &obj)
        {
            const Int *i = dynamic_cast<const Int*>(&obj);
            if (i)
                return int(*i);
            const Real *r = dynamic_cast<const Real*>(&obj);
            if (r)
                return double(*r);
            const String *s = dynamic_cast<const String*>(&obj);
            if (s)
                return s->CStr();
            const StringUTF8 *su = dynamic_cast<const StringUTF8*>(&obj);
            if (su) // works for StringUTF8 and Path
                return *su;
            throw ExceptionInvalidArgument("Cannot convert between these types.");
        }
        template<> inline Path Convert(const Object &obj)
        {
            const Int *i = dynamic_cast<const Int*>(&obj);
            if (i)
                return int(*i);
            const String *s = dynamic_cast<const String*>(&obj);
            if (s)
                return s->CStr();
            const StringUTF8 *su = dynamic_cast<const StringUTF8*>(&obj);
            if (su) // works for StringUTF8 and Path
                return *su;
            throw ExceptionInvalidArgument("Cannot convert between these types.");
        }
        template<> inline Prop3 Convert(const Object &obj)
        {
            const Prop3 *p = dynamic_cast<const Prop3*>(&obj);
            if (p)
                return *p;
            throw ExceptionInvalidArgument("Cannot convert between these types.");
        }
        template<> inline bool Convert(const Object &obj)
        {
            const Int *i = dynamic_cast<const Int*>(&obj);
            if (i)
                return *i != 0;
            const Prop3 *p = dynamic_cast<const Prop3*>(&obj);
            if (p)
                return p->IsTrue();
            throw ExceptionInvalidArgument("Cannot convert between these types.");
        }

        crn::StringUTF8 ASCII85Encode(const uint8_t * const data, size_t len);
        std::vector<uint8_t> ASCII85Decode(const crn::StringUTF8 &s);
        template<typename T> std::vector<T> ASCII85Decode(const crn::StringUTF8 &s)
        {
            const auto deco = ASCII85Decode(s);
            const auto nelem = deco.size() / sizeof(T);
            if (nelem * sizeof(T) != deco.size())
                throw ExceptionDimension{StringUTF8("ASCII85Decode<") + typeid(T).name() + StringUTF8(">(): invalid size.")};
            auto res = std::vector<T>(nelem);
            std::copy(deco.begin(), deco.end(), reinterpret_cast<uint8_t*>(res.data()));
            return res;
        }

    }
}

#endif