hdicoreaiDictionary.h

Go to the documentation of this file.

 
#ifndef __HDI_CORE_AI_DICTIONARY__
#define __HDI_CORE_AI_DICTIONARY__
 
#if defined(HDI_CORE_AIP_MODE)
 
#include "hdicoreTypes.h"
 
namespace hdi
{
    namespace aip
    {
        class IllustratorDictionary;
    }
 
    namespace core
    {
        class Art;
        class UID;
 
        namespace ai
        {
            class Array;
            class Entry;
        
            class Dictionary
            {
                public:
                    class Iterator
                    {
                        public:
                            Iterator(const Iterator& iter_);
 
                            ~Iterator();
                        
                            Iterator& operator=(const Iterator& rhs_);
                            
                            bool operator==(const Iterator& rhs_) const;
                            
                            bool operator!=(const Iterator& rhs_) const;
 
                            Iterator& operator++();
 
                            Iterator operator++(int);
 
                            Iterator& operator--();
 
                            Iterator operator--(int);
 
                            bool atEnd() const;
 
                            std::string key() const;
 
                            std::unique_ptr<Entry> value() const;
 
 
                        private:
                            // Only Dictionary can construct a new Iterator object
                            friend class Dictionary;
 
                            void* __data;
                
                            Iterator();
                        
                            explicit Iterator(const Dictionary& dict_);
                    };
        
                    typedef std::unique_ptr<Iterator> IteratorUP;
                    typedef std::shared_ptr<Iterator> IteratorSP;
                    typedef std::weak_ptr<Iterator> IteratorWP;
 
                    Dictionary();
 
                    Dictionary(const Dictionary& d_);
                
                    Dictionary(const AIDictionaryRef aiDict_);
 
                    virtual ~Dictionary();
            
                    virtual Dictionary& operator=(const Dictionary& rhs_);
                
                    virtual bool operator==(const Dictionary& rhs_) const;
                    
                    virtual bool operator!=(const Dictionary& rhs_) const;
 
                    virtual AIDictionaryRef aiDictionaryRef() const;
 
                    virtual bool getEntry(const std::string& keyName_, Entry& entry__) const;
 
                    virtual bool setEntry(const std::string& keyName_, const Entry& entry_);
 
                    virtual bool deleteEntry(const std::string& keyName_);
 
                    virtual bool getArrayEntry(const std::string& keyName_, Array& array__) const;
 
                    virtual bool setArrayEntry(const std::string& keyName_, const Array& array_);
 
                    virtual bool getBoolEntry(const std::string& keyName_, bool& value__) const;
 
                    virtual bool setBoolEntry(const std::string& keyName_, const bool value_);
 
                    virtual bool getDictEntry(const std::string& keyName_, Dictionary& dict__) const;
 
                    virtual bool setDictEntry(const std::string& keyName_, const Dictionary& dict_);
 
                    virtual bool getIntEntry(const std::string& keyName_, int64_t& value__) const;
 
                    virtual bool setIntEntry(const std::string& keyName_, const int64_t value_);
 
                    virtual bool getFloatEntry(const std::string& keyName_, double& value__) const;
 
                    virtual bool setFloatEntry(const std::string& keyName_, const double value_);
 
                    virtual bool getStringEntry(const std::string& keyName_, std::string& value__) const;
 
                    virtual bool setStringEntry(const std::string& keyName_, const std::string& value_);
 
                    virtual bool getUIDEntry(const std::string& keyName_, UID& uid__) const;
 
                    virtual bool setUIDEntry(const std::string& keyName_, const UID& value_);
 
                    virtual bool getArtEntry(const std::string& keyName_, Art& art__) const;
 
                    virtual bool setArtEntry(const std::string& keyName_, const Art& value_);
 
                    virtual bool hasKey(const std::string& keyName_) const;
                    
                    virtual bool clear();
 
                    Iterator begin() const;
 
 
                private:
                    friend aip::IllustratorDictionary* __accessImpl(const Dictionary&);
                    friend Dictionary __accessCtor(const aip::IllustratorDictionary&);
 
                    aip::IllustratorDictionary* __impl;
 
                    Dictionary(const aip::IllustratorDictionary&);
            };
            
            typedef std::unique_ptr<Dictionary> DictionaryUP;
            typedef std::shared_ptr<Dictionary> DictionarySP;
            typedef std::weak_ptr<Dictionary> DictionaryWP;
            
            extern aip::IllustratorDictionary* __accessImpl(const Dictionary&);
            extern Dictionary __accessCtor(const aip::IllustratorDictionary&);
        }
    }
}
 
#endif
// HDI_CORE_AIP_MODE
 
#endif
// __HDI_CORE_AI_DICTIONARY__