properties.h

Go to the documentation of this file.

/***************************************************************************
 * Copyright 1998-2018 by authors (see AUTHORS.txt)                        *
 *                                                                         *
 *   This file is part of LuxCoreRender.                                   *
 *                                                                         *
 * Licensed under the Apache License, Version 2.0 (the "License");         *
 * you may not use this file except in compliance with the License.        *
 * You may obtain a copy of the License at                                 *
 *                                                                         *
 *     http://www.apache.org/licenses/LICENSE-2.0                          *
 *                                                                         *
 * Unless required by applicable law or agreed to in writing, software     *
 * distributed under the License is distributed on an "AS IS" BASIS,       *
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.*
 * See the License for the specific language governing permissions and     *
 * limitations under the License.                                          *
 ***************************************************************************/

// NOTE: this file is included in LuxCore so any external dependency must be
// avoided here

#ifndef _LUXRAYS_PROPERTIES_H
#define _LUXRAYS_PROPERTIES_H

#include <map>
#include <vector>
#include <string>
#include <istream>
#include <cstdarg>
#include <stdexcept>

#include <luxrays/utils/exportdefs.h>

namespace luxrays {

//------------------------------------------------------------------------------
// Blob class
//------------------------------------------------------------------------------

CPP_EXPORT class CPP_API Blob {
public:
        Blob(const Blob &blob);
        Blob(const char *data, const size_t size);
        Blob(const std::string &base64Data);
        ~Blob();

        const char *GetData() const { return data; }
        size_t GetSize() const { return size; }

        std::string ToString() const;

        Blob &operator=(const Blob &blob);

private:
        char *data;
        size_t size;
};

CPP_EXPORT CPP_API std::ostream &operator<<(std::ostream &os, const Blob &blob);

//------------------------------------------------------------------------------
// Property class
//------------------------------------------------------------------------------

// I was using boost::variant for PropertyValue in the past but I want to avoid
// Boost requirement for application using LuxCore API

CPP_EXPORT class CPP_API PropertyValue {
public:
        typedef enum {
                NONE_VAL,
                BOOL_VAL,
                INT_VAL,
                UINT_VAL,
                FLOAT_VAL,
                DOUBLE_VAL,
                ULONGLONG_VAL,
                STRING_VAL,
                BLOB_VAL
        } DataType;

        PropertyValue();
        PropertyValue(const PropertyValue &propVal);
        PropertyValue(const bool val);
        PropertyValue(const int val);
        PropertyValue(const unsigned int val);
        PropertyValue(const float val);
        PropertyValue(const double val);
        PropertyValue(const unsigned long long val);
        PropertyValue(const std::string &val);
        PropertyValue(const Blob &val);
        ~PropertyValue();

        template<class T> T Get() const;

        DataType GetValueType() const;
        
        PropertyValue &operator=(const PropertyValue &propVal);

private:
        static void Copy(const PropertyValue &prop0Val, PropertyValue &prop1Val);

        DataType dataType;

        union {
                bool boolVal;
                int intVal;
                unsigned int uintVal;
                float floatVal;
                double doubleVal;
                unsigned long long ulonglongVal;
                std::string *stringVal;
                Blob *blobVal;
        } data;
};

// Get<>() basic types specializations
template<> CPP_API bool PropertyValue::Get<bool>() const;
template<> CPP_API int PropertyValue::Get<int>() const;
template<> CPP_API unsigned int PropertyValue::Get<unsigned int>() const;
template<> CPP_API float PropertyValue::Get<float>() const;
template<> CPP_API double PropertyValue::Get<double>() const;
template<> CPP_API unsigned long long PropertyValue::Get<unsigned long long>() const;
template<> CPP_API std::string PropertyValue::Get<std::string>() const;
template<> CPP_API const Blob &PropertyValue::Get<const Blob &>() const;

typedef std::vector<PropertyValue> PropertyValues;

CPP_EXPORT class CPP_API Property {
public:
        Property();
        Property(const std::string &propName);
        Property(const std::string &propName, const PropertyValue &val);
        Property(const std::string &propName, const PropertyValues &vals);
        ~Property();

        const std::string &GetName() const { return name; }
        Property AddedNamePrefix(const std::string &prefix) const {
                Property newProp(prefix + name);
                newProp.values.insert(newProp.values.begin(), values.begin(), values.end());

                return newProp;
        }
        Property Renamed(const std::string &newName) const {
                Property newProp(newName);
                newProp.values.insert(newProp.values.begin(), values.begin(), values.end());

                return newProp;
        }
        unsigned int GetSize() const { return values.size(); }
        Property &Clear();
        template<class T> T Get(const unsigned int index) const {
                if (index >= values.size())
                        throw std::runtime_error("Out of bound error for property: " + name);

                return values[index].Get<T>();
        }
        const PropertyValue::DataType GetValueType(const unsigned int index) const {
                if (index >= values.size())
                        throw std::runtime_error("Out of bound error for property: " + name);

                return values[index].GetValueType();
        }
        template<class T> T Get() const {
                throw std::runtime_error("Unsupported data type in property: " + name);
        }
        template<class T> Property &Set(const unsigned int index, const T &val) {
                if (index >= values.size())
                        throw std::runtime_error("Out of bound error for property: " + name);

                values[index] = val;

                return *this;
        }
        template<class T> Property &Add(const T &val) {
                values.push_back(val);
                return *this;
        }
        std::string GetValuesString() const;
        void FromString(std::string &s);
        std::string ToString() const;
        template<class T0> Property &operator()(const T0 &val0) {
                return Add(val0);
        }
        template<class T0, class T1> Property &operator()(const T0 &val0, const T1 &val1) {
                return Add(val0).Add(val1);
        }
        template<class T0, class T1, class T2> Property &operator()(const T0 &val0, const T1 &val1, const T2 &val2) {
                return Add(val0).Add(val1).Add(val2);
        }
        template<class T0, class T1, class T2, class T3> Property &operator()(const T0 &val0, const T1 &val1, const T2 &val2, const T3 &val3) {
                return Add(val0).Add(val1).Add(val2).Add(val3);
        }
        template<class T0> Property &operator()(const std::vector<T0> &vals) {
                for (size_t i = 0; i < vals.size(); ++i)
                        values.push_back(vals[i]);

                return *this; 
        }
        template<class T> Property &operator=(const T &val) {
                values.clear();
                return Add(val);
        }

        Property &Add(const char *val) {
                values.push_back(std::string(val));
                return *this;
        }
        Property &Add(char *val) {
                values.push_back(std::string(val));
                return *this;
        }
        Property &operator()(const char *val) {
                return Add(std::string(val));
        }
        Property &operator()(char *val) {
                return Add(std::string(val));
        }
        Property &operator=(const char *val) {
                values.clear();
                return Add(std::string(val));
        }
        Property &operator=(char *val) {
                values.clear();
                return Add(std::string(val));
        }

        static unsigned int CountFields(const std::string &name);
        static std::string ExtractField(const std::string &name, const unsigned int index);
        static std::string ExtractPrefix(const std::string &name, const unsigned int count);

private:
        std::string name;
        PropertyValues values;
};      

// Get<>() basic types specializations
template<> CPP_API bool Property::Get<bool>() const;
template<> CPP_API int Property::Get<int>() const;
template<> CPP_API unsigned int Property::Get<unsigned int>() const;
template<> CPP_API float Property::Get<float>() const;
template<> CPP_API double Property::Get<double>() const;
template<> CPP_API unsigned long long Property::Get<unsigned long long>() const;
template<> CPP_API std::string Property::Get<std::string>() const;
template<> CPP_API const Blob &Property::Get<const Blob &>() const;

inline std::ostream &operator<<(std::ostream &os, const Property &p) {
        os << p.ToString();

        return os;
}

//------------------------------------------------------------------------------
// Properties class
//------------------------------------------------------------------------------

CPP_EXPORT class CPP_API Properties {
public:
        Properties() { }
        Properties(const std::string &fileName);
        ~Properties() { }

        unsigned int GetSize() const;

        // The following 2 methods perform the same action

        Properties &Set(const Property &prop);
        Properties &operator<<(const Property &prop);
        Properties &Set(const Properties &prop);
        Properties &operator<<(const Properties &props);
        Properties &Set(const Properties &props, const std::string &prefix);
        Properties &SetFromStream(std::istream &stream);
        Properties &SetFromFile(const std::string &fileName);
        Properties &SetFromString(const std::string &propDefinitions);

        Properties &Clear();

        const std::vector<std::string> &GetAllNames() const;
        std::vector<std::string> GetAllNames(const std::string &prefix) const;
        std::vector<std::string> GetAllNamesRE(const std::string &regularExpression) const;
        std::vector<std::string> GetAllUniqueSubNames(const std::string &prefix) const;
        bool HaveNames(const std::string &prefix) const;
        bool HaveNamesRE(const std::string &regularExpression) const;
        Properties GetAllProperties(const std::string &prefix) const;
        const Property &Get(const std::string &propName) const;
        const Property &Get(const Property &defaultProp) const;

        bool IsDefined(const std::string &propName) const;

        void Delete(const std::string &propName);
        void DeleteAll(const std::vector<std::string> &propNames);

        std::string ToString() const;

private:
        // This vector is used, among other things, to keep track of the insertion order
        std::vector<std::string> names;
        std::map<std::string, Property> props;
};

CPP_EXPORT CPP_API Properties operator<<(const Property &prop0, const Property &prop1);
CPP_EXPORT CPP_API Properties operator<<(const Property &prop0, const Properties &props);

inline std::ostream &operator<<(std::ostream &os, const Properties &p) {
        os << p.ToString();

        return os;
}

}

#endif  /* _LUXRAYS_PROPERTIES_H */