NamePreparator.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_NAMEPREPARATOR_H_
#define PRTX_NAMEPREPARATOR_H_

#include "prtx/prtx.h"

#include <string>
#include <memory>

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


namespace prtx {


class PRTX_EXPORTS_API NamePreparator {
public:
    struct NamespaceInfo {
        virtual ~NamespaceInfo() {};

        virtual void reset() = 0;
        virtual uint32_t getType() const = 0;
    };

    typedef std::shared_ptr<NamespaceInfo> NamespacePtr;

    enum Entity {
        ENTITY_MATERIAL,    
        ENTITY_MESH,        
        ENTITY_SHAPE,       
        ENTITY_NODE,        
        ENTITY_TEXTURE,     
        ENTITY_FILE,        
        ENTITY_CUSTOM       
    };

public:
    virtual ~NamePreparator() {}

    virtual NamespacePtr newNamespace() = 0;

    virtual void legalize(std::wstring& name, uint32_t entity) = 0;

    virtual std::wstring legalized(const std::wstring& name, uint32_t entity) {
        std::wstring s(name);
        legalize(s, entity);
        return s;
    }

    virtual void uniquify(std::wstring& name, uint32_t entity, const NamespacePtr& ns) = 0;

    virtual std::wstring uniquified(const std::wstring& name, uint32_t entity, const NamespacePtr& ns) {
        std::wstring s(name);
        uniquify(s, entity, ns);
        return s;
    }

    void legalizeAndUniquify(std::wstring& name, uint32_t entity, const NamespacePtr& ns) {
        legalize(name, entity);
        uniquify(name, entity, ns);
    }

    std::wstring legalizedAndUniquified(const std::wstring& name, uint32_t entity, const NamespacePtr& ns) {
        std::wstring s(name);
        legalizeAndUniquify(s, entity, ns);
        return s;
    }
};


class PRTX_EXPORTS_API DefaultNamePreparator : public prtx::NamePreparator {
public:
    DefaultNamePreparator(const std::wstring& delimiter = L"_", const std::wstring& filenameDelimiter = L"_");

    DefaultNamePreparator(const DefaultNamePreparator&) = delete;
    DefaultNamePreparator& operator=(const DefaultNamePreparator&) = delete;
    virtual ~DefaultNamePreparator() = default;

    NamespacePtr newNamespace() override;

    void legalize(std::wstring& name, uint32_t entity) override;

    void uniquify(std::wstring& name, uint32_t entity, const NamespacePtr& ns) override;

    void setDelimiter(const std::wstring& delimiter);

    void setFilenameDelimiter(const std::wstring& delimiter);

private:
    std::wstring mDelimiter;
    std::wstring mFilenameDelimiter;
};


class PRTX_EXPORTS_API AsciiFileNamePreparator : public prtx::DefaultNamePreparator {
public:
    AsciiFileNamePreparator(const std::wstring& delimiter = L"_", const std::wstring& filenameDelimiter = L"_");

    AsciiFileNamePreparator(const AsciiFileNamePreparator&) = delete;
    AsciiFileNamePreparator& operator=(const AsciiFileNamePreparator&) = delete;
    virtual ~AsciiFileNamePreparator() = default;

    void legalize(std::wstring& name, uint32_t entity) override;
};


} // namespace prtx


#ifdef _MSC_VER
#   pragma warning(pop)
#endif


#endif /* PRTX_NAMEPREPARATOR_H_ */