[android/aapt.git] / ResourceTable.h

//
// Copyright 2006 The Android Open Source Project
//
// Build resource files from raw assets.
//

#ifndef RESOURCE_TABLE_H
#define RESOURCE_TABLE_H

#include "StringPool.h"
#include "SourcePos.h"

class ResourceTable;

enum {
    XML_COMPILE_STRIP_COMMENTS = 1<<0,
    XML_COMPILE_ASSIGN_ATTRIBUTE_IDS = 1<<1,
    XML_COMPILE_COMPACT_WHITESPACE = 1<<2,
    XML_COMPILE_STRIP_WHITESPACE = 1<<3,
    XML_COMPILE_STRIP_RAW_VALUES = 1<<4,
    
    XML_COMPILE_STANDARD_RESOURCE =
            XML_COMPILE_STRIP_COMMENTS | XML_COMPILE_ASSIGN_ATTRIBUTE_IDS
            | XML_COMPILE_STRIP_WHITESPACE | XML_COMPILE_STRIP_RAW_VALUES
};

status_t compileXmlFile(const sp<AaptAssets>& assets,
                        const sp<AaptFile>& target,
                        ResourceTable* table,
                        int options = XML_COMPILE_STANDARD_RESOURCE);

status_t compileResourceFile(Bundle* bundle,
                             const sp<AaptAssets>& assets,
                             const sp<AaptFile>& in,
                             const ResTable_config& defParams,
                             ResourceTable* outTable);

struct AccessorCookie
{
    SourcePos sourcePos;
    String8 attr;
    String8 value;

    AccessorCookie(const SourcePos&p, const String8& a, const String8& v)
        :sourcePos(p),
         attr(a),
         value(v)
    {
    }
};

class ResourceTable : public ResTable::Accessor
{
public:
    class Package;
    class Type;
    class Entry;

    ResourceTable(Bundle* bundle, const String16& assetsPackage);

    status_t addIncludedResources(Bundle* bundle, const sp<AaptAssets>& assets);

    status_t addPublic(const SourcePos& pos,
                       const String16& package,
                       const String16& type,
                       const String16& name,
                       const uint32_t ident);

    status_t addEntry(const SourcePos& pos,
                      const String16& package,
                      const String16& type,
                      const String16& name,
                      const String16& value,
                      const Vector<StringPool::entry_style_span>* style = NULL,
                      const ResTable_config* params = NULL,
                      const bool doSetIndex = false,
                      const int32_t format = ResTable_map::TYPE_ANY);

    status_t startBag(const SourcePos& pos,
                    const String16& package,
                    const String16& type,
                    const String16& name,
                    const String16& bagParent,
                    const ResTable_config* params = NULL,
                    bool replace = false,
                    bool isId = false);
    
    status_t addBag(const SourcePos& pos,
                    const String16& package,
                    const String16& type,
                    const String16& name,
                    const String16& bagParent,
                    const String16& bagKey,
                    const String16& value,
                    const Vector<StringPool::entry_style_span>* style = NULL,
                    const ResTable_config* params = NULL,
                    bool replace = false,
                    bool isId = false,
                    const int32_t format = ResTable_map::TYPE_ANY);

    bool hasBagOrEntry(const String16& package,
                       const String16& type,
                       const String16& name) const;

    bool hasBagOrEntry(const String16& ref,
                       const String16* defType = NULL,
                       const String16* defPackage = NULL);

    bool appendComment(const String16& package,
                       const String16& type,
                       const String16& name,
                       const String16& comment,
                       bool onlyIfEmpty = false);

    bool appendTypeComment(const String16& package,
                           const String16& type,
                           const String16& name,
                           const String16& comment);
    
    size_t size() const;
    size_t numLocalResources() const;
    bool hasResources() const;

    sp<AaptFile> flatten(Bundle*);

    static inline uint32_t makeResId(uint32_t packageId,
                                     uint32_t typeId,
                                     uint32_t nameId)
    {
        return nameId | (typeId<<16) | (packageId<<24);
    }

    static inline uint32_t getResId(const sp<Package>& p,
                                    const sp<Type>& t,
                                    uint32_t nameId);

    uint32_t getResId(const String16& package,
                      const String16& type,
                      const String16& name) const;

    uint32_t getResId(const String16& ref,
                      const String16* defType = NULL,
                      const String16* defPackage = NULL,
                      const char** outErrorMsg = NULL) const;

    static bool isValidResourceName(const String16& s);
    
    bool stringToValue(Res_value* outValue, StringPool* pool,
                       const String16& str,
                       bool preserveSpaces, bool coerceType,
                       uint32_t attrID,
                       const Vector<StringPool::entry_style_span>* style = NULL,
                       String16* outStr = NULL, void* accessorCookie = NULL,
                       uint32_t attrType = ResTable_map::TYPE_ANY);

    status_t assignResourceIds();
    status_t addSymbols(const sp<AaptSymbols>& outSymbols = NULL);

    status_t flatten(Bundle*, const sp<AaptFile>& dest);

    void writePublicDefinitions(const String16& package, FILE* fp);

    virtual uint32_t getCustomResource(const String16& package,
                                       const String16& type,
                                       const String16& name) const;
    virtual uint32_t getCustomResourceWithCreation(const String16& package,
                                                   const String16& type,
                                                   const String16& name,
                                                   const bool createIfNeeded);
    virtual uint32_t getRemappedPackage(uint32_t origPackage) const;
    virtual bool getAttributeType(uint32_t attrID, uint32_t* outType);
    virtual bool getAttributeMin(uint32_t attrID, uint32_t* outMin);
    virtual bool getAttributeMax(uint32_t attrID, uint32_t* outMax);
    virtual bool getAttributeKeys(uint32_t attrID, Vector<String16>* outKeys);
    virtual bool getAttributeEnum(uint32_t attrID,
                                  const char16_t* name, size_t nameLen,
                                  Res_value* outValue);
    virtual bool getAttributeFlags(uint32_t attrID,
                                   const char16_t* name, size_t nameLen,
                                   Res_value* outValue);
    virtual uint32_t getAttributeL10N(uint32_t attrID);

    virtual bool getLocalizationSetting();
    virtual void reportError(void* accessorCookie, const char* fmt, ...);

    void setCurrentXmlPos(const SourcePos& pos) { mCurrentXmlPos = pos; }

    class Item {
    public:
        Item() : isId(false), format(ResTable_map::TYPE_ANY), bagKeyId(0), evaluating(false)
            { memset(&parsedValue, 0, sizeof(parsedValue)); }
        Item(const SourcePos& pos,
             bool _isId,
             const String16& _value,
             const Vector<StringPool::entry_style_span>* _style = NULL,
             int32_t format = ResTable_map::TYPE_ANY);
        Item(const Item& o) : sourcePos(o.sourcePos),
            isId(o.isId), value(o.value), style(o.style),
            format(o.format), bagKeyId(o.bagKeyId), evaluating(false) {
            memset(&parsedValue, 0, sizeof(parsedValue));
        }
        ~Item() { }

        Item& operator=(const Item& o) {
            sourcePos = o.sourcePos;
            isId = o.isId;
            value = o.value;
            style = o.style;
            format = o.format;
            bagKeyId = o.bagKeyId;
            parsedValue = o.parsedValue;
            return *this;
        }

        SourcePos                               sourcePos;
        mutable bool                            isId;
        String16                                value;
        Vector<StringPool::entry_style_span>    style;
        int32_t                                 format;
        uint32_t                                bagKeyId;
        mutable bool                            evaluating;
        Res_value                               parsedValue;
    };

    class Entry : public RefBase {
    public:
        Entry(const String16& name, const SourcePos& pos)
            : mName(name), mType(TYPE_UNKNOWN),
              mItemFormat(ResTable_map::TYPE_ANY), mNameIndex(-1), mPos(pos)
        { }
        virtual ~Entry() { }

        enum type {
            TYPE_UNKNOWN = 0,
            TYPE_ITEM,
            TYPE_BAG
        };
        
        String16 getName() const { return mName; }
        type getType() const { return mType; }

        void setParent(const String16& parent) { mParent = parent; }
        String16 getParent() const { return mParent; }

        status_t makeItABag(const SourcePos& sourcePos);
        
        status_t setItem(const SourcePos& pos,
                         const String16& value,
                         const Vector<StringPool::entry_style_span>* style = NULL,
                         int32_t format = ResTable_map::TYPE_ANY);

        status_t addToBag(const SourcePos& pos,
                          const String16& key, const String16& value,
                          const Vector<StringPool::entry_style_span>* style = NULL,
                          bool replace=false, bool isId = false,
                          int32_t format = ResTable_map::TYPE_ANY);

        // Index of the entry's name string in the key pool.
        int32_t getNameIndex() const { return mNameIndex; }
        void setNameIndex(int32_t index) { mNameIndex = index; }

        const Item* getItem() const { return mType == TYPE_ITEM ? &mItem : NULL; }
        const KeyedVector<String16, Item>& getBag() const { return mBag; }

        status_t generateAttributes(ResourceTable* table,
                                    const String16& package);

        status_t assignResourceIds(ResourceTable* table,
                                   const String16& package);

        status_t prepareFlatten(StringPool* strings, ResourceTable* table);

        ssize_t flatten(Bundle*, const sp<AaptFile>& data, bool isPublic);

        const SourcePos& getPos() const { return mPos; }

    private:
        String16 mName;
        String16 mParent;
        type mType;
        Item mItem;
        int32_t mItemFormat;
        KeyedVector<String16, Item> mBag;
        int32_t mNameIndex;
        uint32_t mParentId;
        SourcePos mPos;
    };

    struct ConfigDescription : public ResTable_config {
        ConfigDescription() {
            memset(this, 0, sizeof(*this));
            size = sizeof(ResTable_config);
        }
        ConfigDescription(const ResTable_config&o) {
            *static_cast<ResTable_config*>(this) = o;
            size = sizeof(ResTable_config);
        }
        ConfigDescription(const ConfigDescription&o) {
            *static_cast<ResTable_config*>(this) = o;
        }
        
        ConfigDescription& operator=(const ResTable_config& o) {
            *static_cast<ResTable_config*>(this) = o;
            size = sizeof(ResTable_config);
            return *this;
        }
        ConfigDescription& operator=(const ConfigDescription& o) {
            *static_cast<ResTable_config*>(this) = o;
            return *this;
        }
        
        inline bool operator<(const ConfigDescription& o) const { return compare(o) < 0; }
        inline bool operator<=(const ConfigDescription& o) const { return compare(o) <= 0; }
        inline bool operator==(const ConfigDescription& o) const { return compare(o) == 0; }
        inline bool operator!=(const ConfigDescription& o) const { return compare(o) != 0; }
        inline bool operator>=(const ConfigDescription& o) const { return compare(o) >= 0; }
        inline bool operator>(const ConfigDescription& o) const { return compare(o) > 0; }
    };
    
    class ConfigList : public RefBase {
    public:
        ConfigList(const String16& name, const SourcePos& pos)
            : mName(name), mPos(pos), mPublic(false), mEntryIndex(-1) { }
        virtual ~ConfigList() { }
        
        String16 getName() const { return mName; }
        const SourcePos& getPos() const { return mPos; }
        
        void appendComment(const String16& comment, bool onlyIfEmpty = false);
        const String16& getComment() const { return mComment; }
        
        void appendTypeComment(const String16& comment);
        const String16& getTypeComment() const { return mTypeComment; }
        
        // Index of this entry in its Type.
        int32_t getEntryIndex() const { return mEntryIndex; }
        void setEntryIndex(int32_t index) { mEntryIndex = index; }
        
        void setPublic(bool pub) { mPublic = pub; }
        bool getPublic() const { return mPublic; }
        void setPublicSourcePos(const SourcePos& pos) { mPublicSourcePos = pos; }
        const SourcePos& getPublicSourcePos() { return mPublicSourcePos; }
        
        void addEntry(const ResTable_config& config, const sp<Entry>& entry) {
            mEntries.add(config, entry);
        }
        
        const DefaultKeyedVector<ConfigDescription, sp<Entry> >& getEntries() const { return mEntries; }
    private:
        const String16 mName;
        const SourcePos mPos;
        String16 mComment;
        String16 mTypeComment;
        bool mPublic;
        SourcePos mPublicSourcePos;
        int32_t mEntryIndex;
        DefaultKeyedVector<ConfigDescription, sp<Entry> > mEntries;
    };
    
    class Public {
    public:
        Public() : sourcePos(), ident(0) { }
        Public(const SourcePos& pos,
               const String16& _comment,
               uint32_t _ident)
            : sourcePos(pos),
            comment(_comment), ident(_ident) { }
        Public(const Public& o) : sourcePos(o.sourcePos),
            comment(o.comment), ident(o.ident) { }
        ~Public() { }
        
        Public& operator=(const Public& o) {
            sourcePos = o.sourcePos;
            comment = o.comment;
            ident = o.ident;
            return *this;
        }
        
        SourcePos   sourcePos;
        String16    comment;
        uint32_t    ident;
    };
    
    class Type : public RefBase {
    public:
        Type(const String16& name, const SourcePos& pos)
                : mName(name), mFirstPublicSourcePos(NULL), mPublicIndex(-1), mIndex(-1), mPos(pos)
        { }
        virtual ~Type() { delete mFirstPublicSourcePos; }

        status_t addPublic(const SourcePos& pos,
                           const String16& name,
                           const uint32_t ident);

        String16 getName() const { return mName; }
        sp<Entry> getEntry(const String16& entry,
                           const SourcePos& pos,
                           const ResTable_config* config = NULL,
                           bool doSetIndex = false);

        const SourcePos& getFirstPublicSourcePos() const { return *mFirstPublicSourcePos; }

        int32_t getPublicIndex() const { return mPublicIndex; }

        int32_t getIndex() const { return mIndex; }
        void setIndex(int32_t index) { mIndex = index; }

        status_t applyPublicEntryOrder();

        const SortedVector<ConfigDescription>& getUniqueConfigs() const { return mUniqueConfigs; }
        
        const DefaultKeyedVector<String16, sp<ConfigList> >& getConfigs() const { return mConfigs; }
        const Vector<sp<ConfigList> >& getOrderedConfigs() const { return mOrderedConfigs; }

        const SourcePos& getPos() const { return mPos; }
    private:
        String16 mName;
        SourcePos* mFirstPublicSourcePos;
        DefaultKeyedVector<String16, Public> mPublic;
        SortedVector<ConfigDescription> mUniqueConfigs;
        DefaultKeyedVector<String16, sp<ConfigList> > mConfigs;
        Vector<sp<ConfigList> > mOrderedConfigs;
        int32_t mPublicIndex;
        int32_t mIndex;
        SourcePos mPos;
    };

    class Package : public RefBase {
    public:
        Package(const String16& name, ssize_t includedId=-1);
        virtual ~Package() { }

        String16 getName() const { return mName; }
        sp<Type> getType(const String16& type,
                         const SourcePos& pos,
                         bool doSetIndex = false);

        ssize_t getAssignedId() const { return mIncludedId; }

        const ResStringPool& getTypeStrings() const { return mTypeStrings; }
        uint32_t indexOfTypeString(const String16& s) const { return mTypeStringsMapping.valueFor(s); }
        const sp<AaptFile> getTypeStringsData() const { return mTypeStringsData; }
        status_t setTypeStrings(const sp<AaptFile>& data);

        const ResStringPool& getKeyStrings() const { return mKeyStrings; }
        uint32_t indexOfKeyString(const String16& s) const { return mKeyStringsMapping.valueFor(s); }
        const sp<AaptFile> getKeyStringsData() const { return mKeyStringsData; }
        status_t setKeyStrings(const sp<AaptFile>& data);

        status_t applyPublicTypeOrder();

        const DefaultKeyedVector<String16, sp<Type> >& getTypes() const { return mTypes; }
        const Vector<sp<Type> >& getOrderedTypes() const { return mOrderedTypes; }

    private:
        status_t setStrings(const sp<AaptFile>& data,
                            ResStringPool* strings,
                            DefaultKeyedVector<String16, uint32_t>* mappings);

        const String16 mName;
        const ssize_t mIncludedId;
        DefaultKeyedVector<String16, sp<Type> > mTypes;
        Vector<sp<Type> > mOrderedTypes;
        sp<AaptFile> mTypeStringsData;
        sp<AaptFile> mKeyStringsData;
        ResStringPool mTypeStrings;
        ResStringPool mKeyStrings;
        DefaultKeyedVector<String16, uint32_t> mTypeStringsMapping;
        DefaultKeyedVector<String16, uint32_t> mKeyStringsMapping;
    };

private:
    void writePublicDefinitions(const String16& package, FILE* fp, bool pub);
    sp<Package> getPackage(const String16& package);
    sp<Type> getType(const String16& package,
                     const String16& type,
                     const SourcePos& pos,
                     bool doSetIndex = false);
    sp<Entry> getEntry(const String16& package,
                       const String16& type,
                       const String16& name,
                       const SourcePos& pos,
                       const ResTable_config* config = NULL,
                       bool doSetIndex = false);
    sp<const Entry> getEntry(uint32_t resID,
                             const ResTable_config* config = NULL) const;
    const Item* getItem(uint32_t resID, uint32_t attrID) const;
    bool getItemValue(uint32_t resID, uint32_t attrID,
                      Res_value* outValue);


    String16 mAssetsPackage;
    sp<AaptAssets> mAssets;
    DefaultKeyedVector<String16, DefaultKeyedVector<String16, uint32_t> > mPublicNames;
    DefaultKeyedVector<String16, sp<Package> > mPackages;
    Vector<sp<Package> > mOrderedPackages;
    uint32_t mNextPackageId;
    bool mHaveAppPackage;
    bool mIsAppPackage;
    size_t mNumLocal;
    SourcePos mCurrentXmlPos;
    Bundle* mBundle;
};

class ResourceFilter
{
public:
    ResourceFilter() : mData(), mContainsPseudo(false) {}
    status_t parse(const char* arg);
    bool match(int axis, uint32_t value);
    bool match(const ResTable_config& config);
    inline bool containsPseudo() { return mContainsPseudo; }

private:
    KeyedVector<int,SortedVector<uint32_t> > mData;
    bool mContainsPseudo;
};


#endif
Commit	Line	Data
dadd9c1f TAOSP	1	//
	2	// Copyright 2006 The Android Open Source Project
	3	//
	4	// Build resource files from raw assets.
	5	//
	6
	7	#ifndef RESOURCE_TABLE_H
	8	#define RESOURCE_TABLE_H
	9
	10	#include "StringPool.h"
	11	#include "SourcePos.h"
	12
	13	class ResourceTable;
	14
	15	enum {
	16	XML_COMPILE_STRIP_COMMENTS = 1<<0,
	17	XML_COMPILE_ASSIGN_ATTRIBUTE_IDS = 1<<1,
	18	XML_COMPILE_COMPACT_WHITESPACE = 1<<2,
	19	XML_COMPILE_STRIP_WHITESPACE = 1<<3,
	20	XML_COMPILE_STRIP_RAW_VALUES = 1<<4,
	21
	22	XML_COMPILE_STANDARD_RESOURCE =
	23	XML_COMPILE_STRIP_COMMENTS \| XML_COMPILE_ASSIGN_ATTRIBUTE_IDS
	24	\| XML_COMPILE_STRIP_WHITESPACE \| XML_COMPILE_STRIP_RAW_VALUES
	25	};
	26
	27	status_t compileXmlFile(const sp<AaptAssets>& assets,
	28	const sp<AaptFile>& target,
	29	ResourceTable* table,
	30	int options = XML_COMPILE_STANDARD_RESOURCE);
	31
	32	status_t compileResourceFile(Bundle* bundle,
	33	const sp<AaptAssets>& assets,
	34	const sp<AaptFile>& in,
	35	const ResTable_config& defParams,
	36	ResourceTable* outTable);
	37
	38	struct AccessorCookie
	39	{
	40	SourcePos sourcePos;
	41	String8 attr;
	42	String8 value;
	43
	44	AccessorCookie(const SourcePos&p, const String8& a, const String8& v)
	45	:sourcePos(p),
	46	attr(a),
	47	value(v)
	48	{
	49	}
	50	};
	51
	52	class ResourceTable : public ResTable::Accessor
	53	{
	54	public:
	55	class Package;
	56	class Type;
	57	class Entry;
	58
	59	ResourceTable(Bundle* bundle, const String16& assetsPackage);
	60
	61	status_t addIncludedResources(Bundle* bundle, const sp<AaptAssets>& assets);
	62
	63	status_t addPublic(const SourcePos& pos,
	64	const String16& package,
65	const String16& type,
66	const String16& name,
67	const uint32_t ident);
68
69	status_t addEntry(const SourcePos& pos,
70	const String16& package,
71	const String16& type,
72	const String16& name,
73	const String16& value,
74	const Vector<StringPool::entry_style_span>* style = NULL,
75	const ResTable_config* params = NULL,
76	const bool doSetIndex = false,
77	const int32_t format = ResTable_map::TYPE_ANY);
78
79	status_t startBag(const SourcePos& pos,
80	const String16& package,
81	const String16& type,
82	const String16& name,
83	const String16& bagParent,
84	const ResTable_config* params = NULL,
85	bool replace = false,
86	bool isId = false);
87
88	status_t addBag(const SourcePos& pos,
89	const String16& package,
90	const String16& type,
91	const String16& name,
92	const String16& bagParent,
93	const String16& bagKey,
94	const String16& value,
95	const Vector<StringPool::entry_style_span>* style = NULL,
96	const ResTable_config* params = NULL,
97	bool replace = false,
98	bool isId = false,
99	const int32_t format = ResTable_map::TYPE_ANY);
100
101	bool hasBagOrEntry(const String16& package,
102	const String16& type,
103	const String16& name) const;
104
105	bool hasBagOrEntry(const String16& ref,
106	const String16* defType = NULL,
107	const String16* defPackage = NULL);
108
109	bool appendComment(const String16& package,
110	const String16& type,
111	const String16& name,
112	const String16& comment,
113	bool onlyIfEmpty = false);
114
115	bool appendTypeComment(const String16& package,
116	const String16& type,
117	const String16& name,
118	const String16& comment);
119
120	size_t size() const;
121	size_t numLocalResources() const;
122	bool hasResources() const;
123
124	sp<AaptFile> flatten(Bundle*);
125
126	static inline uint32_t makeResId(uint32_t packageId,
127	uint32_t typeId,
128	uint32_t nameId)
129	{
130	return nameId \| (typeId<<16) \| (packageId<<24);
131	}
132
133	static inline uint32_t getResId(const sp<Package>& p,
134	const sp<Type>& t,
135	uint32_t nameId);
136
137	uint32_t getResId(const String16& package,
138	const String16& type,
139	const String16& name) const;
140
141	uint32_t getResId(const String16& ref,
142	const String16* defType = NULL,
143	const String16* defPackage = NULL,
144	const char** outErrorMsg = NULL) const;
145
146	static bool isValidResourceName(const String16& s);
147
148	bool stringToValue(Res_value* outValue, StringPool* pool,
149	const String16& str,
150	bool preserveSpaces, bool coerceType,
151	uint32_t attrID,
152	const Vector<StringPool::entry_style_span>* style = NULL,
153	String16* outStr = NULL, void* accessorCookie = NULL,
154	uint32_t attrType = ResTable_map::TYPE_ANY);
155
156	status_t assignResourceIds();
157	status_t addSymbols(const sp<AaptSymbols>& outSymbols = NULL);
158
159	status_t flatten(Bundle*, const sp<AaptFile>& dest);
160
161	void writePublicDefinitions(const String16& package, FILE* fp);
162
163	virtual uint32_t getCustomResource(const String16& package,
164	const String16& type,
165	const String16& name) const;
166	virtual uint32_t getCustomResourceWithCreation(const String16& package,
167	const String16& type,
168	const String16& name,
169	const bool createIfNeeded);
170	virtual uint32_t getRemappedPackage(uint32_t origPackage) const;
171	virtual bool getAttributeType(uint32_t attrID, uint32_t* outType);
172	virtual bool getAttributeMin(uint32_t attrID, uint32_t* outMin);
173	virtual bool getAttributeMax(uint32_t attrID, uint32_t* outMax);
174	virtual bool getAttributeKeys(uint32_t attrID, Vector<String16>* outKeys);
175	virtual bool getAttributeEnum(uint32_t attrID,
176	const char16_t* name, size_t nameLen,
177	Res_value* outValue);
178	virtual bool getAttributeFlags(uint32_t attrID,
179	const char16_t* name, size_t nameLen,
180	Res_value* outValue);
181	virtual uint32_t getAttributeL10N(uint32_t attrID);
182
183	virtual bool getLocalizationSetting();
184	virtual void reportError(void* accessorCookie, const char* fmt, ...);
185
186	void setCurrentXmlPos(const SourcePos& pos) { mCurrentXmlPos = pos; }
187
188	class Item {
189	public:
190	Item() : isId(false), format(ResTable_map::TYPE_ANY), bagKeyId(0), evaluating(false)
191	{ memset(&parsedValue, 0, sizeof(parsedValue)); }
192	Item(const SourcePos& pos,
193	bool _isId,
194	const String16& _value,
195	const Vector<StringPool::entry_style_span>* _style = NULL,
196	int32_t format = ResTable_map::TYPE_ANY);
197	Item(const Item& o) : sourcePos(o.sourcePos),
198	isId(o.isId), value(o.value), style(o.style),
199	format(o.format), bagKeyId(o.bagKeyId), evaluating(false) {
200	memset(&parsedValue, 0, sizeof(parsedValue));
201	}
202	~Item() { }
203
204	Item& operator=(const Item& o) {
205	sourcePos = o.sourcePos;
206	isId = o.isId;
207	value = o.value;
208	style = o.style;
209	format = o.format;
210	bagKeyId = o.bagKeyId;
211	parsedValue = o.parsedValue;
212	return *this;
213	}
214
215	SourcePos sourcePos;
216	mutable bool isId;
217	String16 value;
218	Vector<StringPool::entry_style_span> style;
219	int32_t format;
220	uint32_t bagKeyId;
221	mutable bool evaluating;
222	Res_value parsedValue;
223	};
224
225	class Entry : public RefBase {
226	public:
227	Entry(const String16& name, const SourcePos& pos)
228	: mName(name), mType(TYPE_UNKNOWN),
229	mItemFormat(ResTable_map::TYPE_ANY), mNameIndex(-1), mPos(pos)
230	{ }
231	virtual ~Entry() { }
232
233	enum type {
234	TYPE_UNKNOWN = 0,
235	TYPE_ITEM,
236	TYPE_BAG
237	};
238
239	String16 getName() const { return mName; }
240	type getType() const { return mType; }
241
242	void setParent(const String16& parent) { mParent = parent; }
243	String16 getParent() const { return mParent; }
244
245	status_t makeItABag(const SourcePos& sourcePos);
246
247	status_t setItem(const SourcePos& pos,
248	const String16& value,
249	const Vector<StringPool::entry_style_span>* style = NULL,
250	int32_t format = ResTable_map::TYPE_ANY);
251
252	status_t addToBag(const SourcePos& pos,
253	const String16& key, const String16& value,
254	const Vector<StringPool::entry_style_span>* style = NULL,
255	bool replace=false, bool isId = false,
256	int32_t format = ResTable_map::TYPE_ANY);
257
258	// Index of the entry's name string in the key pool.
259	int32_t getNameIndex() const { return mNameIndex; }
260	void setNameIndex(int32_t index) { mNameIndex = index; }
261
262	const Item* getItem() const { return mType == TYPE_ITEM ? &mItem : NULL; }
263	const KeyedVector<String16, Item>& getBag() const { return mBag; }
264
265	status_t generateAttributes(ResourceTable* table,
266	const String16& package);
267
268	status_t assignResourceIds(ResourceTable* table,
269	const String16& package);
270
271	status_t prepareFlatten(StringPool* strings, ResourceTable* table);
272
273	ssize_t flatten(Bundle*, const sp<AaptFile>& data, bool isPublic);
274
275	const SourcePos& getPos() const { return mPos; }
276
277	private:
278	String16 mName;
279	String16 mParent;
280	type mType;
281	Item mItem;
282	int32_t mItemFormat;
283	KeyedVector<String16, Item> mBag;
284	int32_t mNameIndex;
285	uint32_t mParentId;
286	SourcePos mPos;
287	};
288
289	struct ConfigDescription : public ResTable_config {
290	ConfigDescription() {
291	memset(this, 0, sizeof(*this));
292	size = sizeof(ResTable_config);
293	}
294	ConfigDescription(const ResTable_config&o) {
295	static_cast<ResTable_config>(this) = o;
296	size = sizeof(ResTable_config);
297	}
298	ConfigDescription(const ConfigDescription&o) {
299	static_cast<ResTable_config>(this) = o;
300	}
301
302	ConfigDescription& operator=(const ResTable_config& o) {
303	static_cast<ResTable_config>(this) = o;
304	size = sizeof(ResTable_config);
305	return *this;
306	}
307	ConfigDescription& operator=(const ConfigDescription& o) {
308	static_cast<ResTable_config>(this) = o;
309	return *this;
310	}
311
312	inline bool operator<(const ConfigDescription& o) const { return compare(o) < 0; }
313	inline bool operator<=(const ConfigDescription& o) const { return compare(o) <= 0; }
314	inline bool operator==(const ConfigDescription& o) const { return compare(o) == 0; }
315	inline bool operator!=(const ConfigDescription& o) const { return compare(o) != 0; }
316	inline bool operator>=(const ConfigDescription& o) const { return compare(o) >= 0; }
317	inline bool operator>(const ConfigDescription& o) const { return compare(o) > 0; }
318	};
319
320	class ConfigList : public RefBase {
321	public:
322	ConfigList(const String16& name, const SourcePos& pos)
323	: mName(name), mPos(pos), mPublic(false), mEntryIndex(-1) { }
324	virtual ~ConfigList() { }
325
326	String16 getName() const { return mName; }
327	const SourcePos& getPos() const { return mPos; }
328
329	void appendComment(const String16& comment, bool onlyIfEmpty = false);
330	const String16& getComment() const { return mComment; }
331
332	void appendTypeComment(const String16& comment);
333	const String16& getTypeComment() const { return mTypeComment; }
334
335	// Index of this entry in its Type.
336	int32_t getEntryIndex() const { return mEntryIndex; }
337	void setEntryIndex(int32_t index) { mEntryIndex = index; }
338
339	void setPublic(bool pub) { mPublic = pub; }
340	bool getPublic() const { return mPublic; }
341	void setPublicSourcePos(const SourcePos& pos) { mPublicSourcePos = pos; }
342	const SourcePos& getPublicSourcePos() { return mPublicSourcePos; }
343
344	void addEntry(const ResTable_config& config, const sp<Entry>& entry) {
345	mEntries.add(config, entry);
346	}
347
348	const DefaultKeyedVector<ConfigDescription, sp<Entry> >& getEntries() const { return mEntries; }
349	private:
350	const String16 mName;
351	const SourcePos mPos;
352	String16 mComment;
353	String16 mTypeComment;
354	bool mPublic;
355	SourcePos mPublicSourcePos;
356	int32_t mEntryIndex;
357	DefaultKeyedVector<ConfigDescription, sp<Entry> > mEntries;
358	};
359
360	class Public {
361	public:
362	Public() : sourcePos(), ident(0) { }
363	Public(const SourcePos& pos,
364	const String16& _comment,
365	uint32_t _ident)
366	: sourcePos(pos),
367	comment(_comment), ident(_ident) { }
368	Public(const Public& o) : sourcePos(o.sourcePos),
369	comment(o.comment), ident(o.ident) { }
370	~Public() { }
371
372	Public& operator=(const Public& o) {
373	sourcePos = o.sourcePos;
374	comment = o.comment;
375	ident = o.ident;
376	return *this;
377	}
378
379	SourcePos sourcePos;
380	String16 comment;
381	uint32_t ident;
382	};
383
384	class Type : public RefBase {
385	public:
386	Type(const String16& name, const SourcePos& pos)
387	: mName(name), mFirstPublicSourcePos(NULL), mPublicIndex(-1), mIndex(-1), mPos(pos)
388	{ }
389	virtual ~Type() { delete mFirstPublicSourcePos; }
390
391	status_t addPublic(const SourcePos& pos,
392	const String16& name,
393	const uint32_t ident);
394
395	String16 getName() const { return mName; }
396	sp<Entry> getEntry(const String16& entry,
397	const SourcePos& pos,
398	const ResTable_config* config = NULL,
399	bool doSetIndex = false);
400
401	const SourcePos& getFirstPublicSourcePos() const { return *mFirstPublicSourcePos; }
402
403	int32_t getPublicIndex() const { return mPublicIndex; }
404
405	int32_t getIndex() const { return mIndex; }
406	void setIndex(int32_t index) { mIndex = index; }
407
408	status_t applyPublicEntryOrder();
409
410	const SortedVector<ConfigDescription>& getUniqueConfigs() const { return mUniqueConfigs; }
411
412	const DefaultKeyedVector<String16, sp<ConfigList> >& getConfigs() const { return mConfigs; }
413	const Vector<sp<ConfigList> >& getOrderedConfigs() const { return mOrderedConfigs; }
414
415	const SourcePos& getPos() const { return mPos; }
416	private:
417	String16 mName;
418	SourcePos* mFirstPublicSourcePos;
419	DefaultKeyedVector<String16, Public> mPublic;
420	SortedVector<ConfigDescription> mUniqueConfigs;
421	DefaultKeyedVector<String16, sp<ConfigList> > mConfigs;
422	Vector<sp<ConfigList> > mOrderedConfigs;
423	int32_t mPublicIndex;
424	int32_t mIndex;
425	SourcePos mPos;
426	};
427
428	class Package : public RefBase {
429	public:
430	Package(const String16& name, ssize_t includedId=-1);
431	virtual ~Package() { }
432
433	String16 getName() const { return mName; }
434	sp<Type> getType(const String16& type,
435	const SourcePos& pos,
436	bool doSetIndex = false);
437
438	ssize_t getAssignedId() const { return mIncludedId; }
439
440	const ResStringPool& getTypeStrings() const { return mTypeStrings; }
441	uint32_t indexOfTypeString(const String16& s) const { return mTypeStringsMapping.valueFor(s); }
442	const sp<AaptFile> getTypeStringsData() const { return mTypeStringsData; }
443	status_t setTypeStrings(const sp<AaptFile>& data);
444
445	const ResStringPool& getKeyStrings() const { return mKeyStrings; }
446	uint32_t indexOfKeyString(const String16& s) const { return mKeyStringsMapping.valueFor(s); }
447	const sp<AaptFile> getKeyStringsData() const { return mKeyStringsData; }
448	status_t setKeyStrings(const sp<AaptFile>& data);
449
450	status_t applyPublicTypeOrder();
451
452	const DefaultKeyedVector<String16, sp<Type> >& getTypes() const { return mTypes; }
453	const Vector<sp<Type> >& getOrderedTypes() const { return mOrderedTypes; }
454
455	private:
456	status_t setStrings(const sp<AaptFile>& data,
457	ResStringPool* strings,
458	DefaultKeyedVector<String16, uint32_t>* mappings);
459
460	const String16 mName;
461	const ssize_t mIncludedId;
462	DefaultKeyedVector<String16, sp<Type> > mTypes;
463	Vector<sp<Type> > mOrderedTypes;
464	sp<AaptFile> mTypeStringsData;
465	sp<AaptFile> mKeyStringsData;
466	ResStringPool mTypeStrings;
467	ResStringPool mKeyStrings;
468	DefaultKeyedVector<String16, uint32_t> mTypeStringsMapping;
469	DefaultKeyedVector<String16, uint32_t> mKeyStringsMapping;
470	};
471
472	private:
473	void writePublicDefinitions(const String16& package, FILE* fp, bool pub);
474	sp<Package> getPackage(const String16& package);
475	sp<Type> getType(const String16& package,
476	const String16& type,
477	const SourcePos& pos,
478	bool doSetIndex = false);
479	sp<Entry> getEntry(const String16& package,
480	const String16& type,
481	const String16& name,
482	const SourcePos& pos,
483	const ResTable_config* config = NULL,
484	bool doSetIndex = false);
485	sp<const Entry> getEntry(uint32_t resID,
486	const ResTable_config* config = NULL) const;
487	const Item* getItem(uint32_t resID, uint32_t attrID) const;
488	bool getItemValue(uint32_t resID, uint32_t attrID,
489	Res_value* outValue);
490
491
492	String16 mAssetsPackage;
493	sp<AaptAssets> mAssets;
494	DefaultKeyedVector<String16, DefaultKeyedVector<String16, uint32_t> > mPublicNames;
495	DefaultKeyedVector<String16, sp<Package> > mPackages;
496	Vector<sp<Package> > mOrderedPackages;
497	uint32_t mNextPackageId;
498	bool mHaveAppPackage;
499	bool mIsAppPackage;
500	size_t mNumLocal;
501	SourcePos mCurrentXmlPos;
502	Bundle* mBundle;
503	};
504
505	class ResourceFilter
506	{
507	public:
508	ResourceFilter() : mData(), mContainsPseudo(false) {}
509	status_t parse(const char* arg);
510	bool match(int axis, uint32_t value);
511	bool match(const ResTable_config& config);
512	inline bool containsPseudo() { return mContainsPseudo; }
513
514	private:
515	KeyedVector<int,SortedVector<uint32_t> > mData;
516	bool mContainsPseudo;
517	};
518
519
520	#endif