EncodeOptions.h

/*
  COPYRIGHT (c) 2012-2024 Esri R&D Center Zurich
  TRADE SECRETS: ESRI PROPRIETARY AND CONFIDENTIAL
  Unpublished material - all rights reserved under the
  Copyright Laws of the United States and applicable international
  laws, treaties, and conventions.

  For additional information, contact:
  Environmental Systems Research Institute, Inc.
  Attn: Contracts and Legal Services Department
  380 New York Street
  Redlands, California, 92373
  USA

  email: contracts@esri.com
*/

#ifndef PRTX_ENCODEOPTIONS_H_
#define PRTX_ENCODEOPTIONS_H_

#include "prtx.h"
#include "prtx/AnnotationBuilder.h"
#include "prtx/EncoderInfoBuilder.h"
#include "prtx/EncoderFactory.h"

#include <string>
#include <vector>

#ifdef _MSC_VER
#   pragma warning(push)
#   pragma warning (disable : 4251 4231 4275 4660)
#endif


namespace prtx {


class PRTX_EXPORTS_API StringEnum {
public:
    struct Item {
        int id;
        std::wstring value;
        std::wstring description;
    };

    struct PodItem {
        int id;
        const wchar_t* value;
        const wchar_t* description;
    };

public:
    StringEnum();

    template<size_t N>
    StringEnum(const Item (&items)[N])
    : mItems(&items[0], &items[N])
      {
        init(0);
      }

    template<size_t N>
    StringEnum(const PodItem (&items)[N])
    : mItems(N)
      {
        init(&items[0]);
      }

    template<size_t N>
    StringEnum(const StringEnum& base, const int (&itemsToKeep)[N]) {
        init(base.beginItems(), base.endItems(), itemsToKeep, N);
    }

    void addItem(int id, const wchar_t* value, const wchar_t* description);
    bool removeItem(int id);

    template<size_t N>
    void addItems(const StringEnum& base, const int (&itemsToKeep)[N]) {
        addItems(base.beginItems(), base.endItems(), itemsToKeep, N);
    }
    void removeAllItems();

    int getIdByValue(const std::wstring& value) const;
    int getIdByValue(const wchar_t* value) const;
    const std::wstring& getValueById(int id) const;
    const wchar_t* getCValueById(int id) const;
    const std::wstring& operator[](int id) const;

    typedef std::vector<Item>::const_iterator ItemConstIter;

    ItemConstIter beginItems() const {
        return mItems.begin();
    }

    ItemConstIter endItems() const {
        return mItems.end();
    }

private:
    void init(const PodItem* items);
    void init(ItemConstIter itemsBegin, ItemConstIter itemsEnd, const int* itemsToKeep, size_t numItemsToKeep);
    void addItems(ItemConstIter itemsBegin, ItemConstIter itemsEnd, const int* itemsToKeep, size_t numItemsToKeep);
    void updateIdEqualsIndex();

private:
    std::vector<Item> mItems;
    bool mIdEqualsIndex;
};


namespace Annotations {


const std::wstring ORDER        = L"@Order";        
const std::wstring LABEL        = L"@Label";        
const std::wstring GROUP        = L"@Group";        
const std::wstring DESCRIPTION  = L"@Description";  
const std::wstring RANGE        = L"@Range";        
const std::wstring POINT2D      = L"@Point2D";      
const std::wstring POINT3D      = L"@Point3D";      
const std::wstring PERLAYER     = L"@PerLayer";     
const std::wstring HIDDEN       = L"@Hidden";       
const std::wstring MANDATORY    = L"@Mandatory";    


} // namespace Annotations


class PRTX_EXPORTS_API EncodeOptionsAnnotator {
public:
    class OptionAnnotator;

private:
    template<typename Opt>
    class AnnotationAdder;

public:
    EncodeOptionsAnnotator(EncoderInfoBuilder& infoBuilder);
    EncodeOptionsAnnotator(const EncodeOptionsAnnotator&) = delete;
    EncodeOptionsAnnotator& operator=(const EncodeOptionsAnnotator&) = delete;

    OptionAnnotator option(const std::wstring& optionKey);

    void setLabel(const std::wstring& optionKey, const std::wstring& label);

    void setDescription(const std::wstring& optionKey, const std::wstring& desc);

    void setOrder(const std::wstring& optionKey, const double& order);

    void setGroup(const std::wstring& optionKey, const std::wstring& groupName, const double& order);

    void setRange(const std::wstring& optionKey, double min, double max);

    void setEnumerants(const std::wstring& optionKey, const StringEnum& items);

    void flagAsPoint2D(const std::wstring& optionKey);

    void flagAsPoint3D(const std::wstring& optionKey);

    void flagAsPerLayer(const std::wstring& optionKey, const std::wstring& layerDefault);

    void flagAsPerLayer(const std::wstring& optionKey, const double& layerDefault);

    void flagAsPerLayer(const std::wstring& optionKey, const bool& layerDefault);

    void flagAsPerLayer(const std::wstring& optionKey, const int32_t& layerDefault);

    void flagAsHidden(const std::wstring& optionKey);

    void flagAsMandatory(const std::wstring& optionKey);

public:

    class PRTX_EXPORTS_API OptionAnnotator {
    public:
        OptionAnnotator(EncodeOptionsAnnotator& annotator, const std::wstring& optionKey)
        : mAnnotator(annotator), mOptionKey(optionKey) {}

        OptionAnnotator(const OptionAnnotator& rhs) : mAnnotator(rhs.mAnnotator), mOptionKey(rhs.mOptionKey) { }

        OptionAnnotator& operator=(const OptionAnnotator&) = delete;

    public:
        OptionAnnotator& setLabel(const std::wstring& label) {
            mAnnotator.setLabel(mOptionKey, label);
            return *this;
        }

        OptionAnnotator& setDescription(const std::wstring& desc) {
            mAnnotator.setDescription(mOptionKey, desc);
            return *this;
        }

        OptionAnnotator& setOrder(const double& order) {
            mAnnotator.setOrder(mOptionKey, order);
            return *this;
        }

        OptionAnnotator& setGroup(const std::wstring& name, const double& order) {
            mAnnotator.setGroup(mOptionKey, name, order);
            return *this;
        }

        OptionAnnotator& flagAsPoint2D() {
            mAnnotator.flagAsPoint2D(mOptionKey);
            return *this;
        }

        OptionAnnotator& flagAsPoint3D() {
            mAnnotator.flagAsPoint3D(mOptionKey);
            return *this;
        }

        OptionAnnotator& flagAsHidden() {
            mAnnotator.flagAsHidden(mOptionKey);
            return *this;
        }

        OptionAnnotator& flagAsMandatory() {
            mAnnotator.flagAsMandatory(mOptionKey);
            return *this;
        }

        template<typename T> OptionAnnotator& flagAsPerLayer(const T& layerDefault) {
            mAnnotator.flagAsPerLayer(mOptionKey, layerDefault);
            return *this;
        }

        OptionAnnotator& setRange(double min, double max) {
            mAnnotator.setRange(mOptionKey, min, max);
            return *this;
        }

        OptionAnnotator& setEnumerants(const StringEnum& items) {
            mAnnotator.setEnumerants(mOptionKey, items);
            return *this;
        }

    private:
        EncodeOptionsAnnotator& mAnnotator;
        const std::wstring& mOptionKey;

        //friend class EncodeOptionsAnnotator;
    };

protected:
    EncoderInfoBuilder& mInfoBuilder;
    AnnotationBuilder mAnnotationBuilder;
};


} // namespace prtx


#ifdef _MSC_VER
#   pragma warning(pop)
#endif


#endif /* PRTX_ENCODEOPTIONS_H_ */