Package ghidra.program.model.data

Interface DataTypeManager

    • Field Detail

      • DEFAULT_DATATYPE_ID

        static final long DEFAULT_DATATYPE_ID
        ID for the default (undefined) data type.
        See Also:
        Constant Field Values

      • NULL_DATATYPE_ID

        static final long NULL_DATATYPE_ID
        ID if data type type is not known in this data type manager.
        See Also:
        Constant Field Values

      • BAD_DATATYPE_ID

        static final long BAD_DATATYPE_ID
        ID if data type type is BAD.
        See Also:
        Constant Field Values

      • BUILT_IN_DATA_TYPES_NAME

        static final java.lang.String BUILT_IN_DATA_TYPES_NAME
        Name of the category for the build in data types.
        See Also:
        Constant Field Values

      • LOCAL_ARCHIVE_UNIVERSAL_ID

        static final UniversalID LOCAL_ARCHIVE_UNIVERSAL_ID

      • BUILT_IN_ARCHIVE_UNIVERSAL_ID

        static final UniversalID BUILT_IN_ARCHIVE_UNIVERSAL_ID

    • Method Detail

      • getUniversalID

        UniversalID getUniversalID()
        Returns the universal ID for this dataType manager
        Returns:
        the universal ID for this dataType manager

      • containsCategory

        boolean containsCategory​(CategoryPath path)
        Returns true if the given category path exists in this datatype manager
        Parameters:
        path - the path
        Returns:
        true if the given category path exists in this datatype manager

      • getUniqueName

        java.lang.String getUniqueName​(CategoryPath path,
                               java.lang.String baseName)
        Returns a unique name not currently used by any other dataType or category with the same baseName
        Parameters:
        path - the path of the name
        baseName - the base name to be made unique
        Returns:
        a unique name starting with baseName

      • resolve

        DataType resolve​(DataType dataType,
                 DataTypeConflictHandler handler)
        Returns a dataType that is "in" (ie suitable implementation) this Manager, creating a new one if necessary. Also the returned dataType will be in a category in this dataTypeManager that is equivalent to the category of the passed in dataType.
        Parameters:
        dataType - the dataType to be resolved.
        handler - used to resolve conflicts with existing dataTypes.
        Returns:
        an equivalent dataType that "belongs" to this dataTypeManager.

      • addDataType

        DataType addDataType​(DataType dataType,
                     DataTypeConflictHandler handler)
        Returns a data type after adding it to this data manager. The returned dataType will be in a category in this dataTypeManager that is equivalent to the category of the passed in dataType.
        Parameters:
        dataType - the dataType to be resolved.
        handler - used to resolve conflicts with existing dataTypes.
        Returns:
        an equivalent dataType that "belongs" to this dataTypeManager.

      • addDataTypes

        void addDataTypes​(java.util.Collection<DataType> dataTypes,
                  DataTypeConflictHandler handler,
                  TaskMonitor monitor)
           throws CancelledException
        Sequentially adds a collection of datatypes to this data manager. This method provides the added benefit of equivalence caching for improved performance.
        WARNING: This is an experimental method whose use may cause the GUI and task monitor to become unresponsive due to extended hold times on the manager lock.
        Parameters:
        dataTypes - collection of datatypes
        handler - conflict handler
        monitor - task monitor
        Throws:
        CancelledException - if monitor is cancelled

      • getAllDataTypes

        java.util.Iterator<DataType> getAllDataTypes()
        Returns an iterator over all the dataTypes in this manager
        Returns:
        an iterator over all the dataTypes in this manager

      • getAllDataTypes

        void getAllDataTypes​(java.util.List<DataType> list)
        Adds all data types to the specified list.]
        Parameters:
        list - the result list into which the types will be placed

      • getAllStructures

        java.util.Iterator<Structure> getAllStructures()
        Returns an iterator over all structures in this manager
        Returns:
        the iterator

      • getAllComposites

        java.util.Iterator<Composite> getAllComposites()
        Returns an iterator over all composite data types (structures and unions) in this manager
        Returns:
        the iterator

      • findDataTypes

        void findDataTypes​(java.lang.String name,
                   java.util.List<DataType> list)
        Begin searching at the root category for all data types with the given name. Places all the data types in this data type manager with the given name into the list.
        Parameters:
        name - name of the data type
        list - list that will be populated with matching DataType objects

      • findDataTypes

        void findDataTypes​(java.lang.String name,
                   java.util.List<DataType> list,
                   boolean caseSensitive,
                   TaskMonitor monitor)
        Begin searching at the root category for all data types with names that match the given name that may contain wildcards.
        Parameters:
        name - name to match; may contain wildcards
        list - list that will be populated with matching DataType objects
        caseSensitive - true if the match is case sensitive
        monitor - task monitor to cancel the search

      • replaceDataType

        DataType replaceDataType​(DataType existingDt,
                         DataType replacementDt,
                         boolean updateCategoryPath)
                  throws DataTypeDependencyException
        Replace an existing dataType with another. All instances and references will be updated to use the replacement dataType.
        Parameters:
        existingDt - the dataType to be replaced.
        replacementDt - the dataType to use as the replacement.
        updateCategoryPath - if true, the replacementDt will have its categoryPath changed to the exitingDt's path.
        Returns:
        the resolved replacement dataType.
        Throws:
        DataTypeDependencyException - if the replacement datatype depends on the existing dataType;

      • getDataType

        DataType getDataType​(java.lang.String dataTypePath)
        Retrieve the data type with the fully qualified path. So you can get the data named "bar" in the category "foo" by calling getDataType("/foo/bar"). This method can be problematic now that datatype names can contain slashes. It will work provided that the part of the datatype name that precedes its internal slash is not also the name of a category in the same category as the datatype. For example, if you call getDataType("/a/b/c"), and "b/c" is the name of your datatype, it will find it unless there is also a category "b" under category "a". A better solution is to use the getDataType(DataTypePath) method because the DataTypePath keeps the category and datatype name separate.
        Parameters:
        dataTypePath - path
        Returns:
        the dataType or null if it isn't found

      • getDataType

        DataType getDataType​(DataTypePath dataTypePath)
        Find the dataType for the given dataTypePath.
        Parameters:
        dataTypePath - the DataTypePath for the datatype
        Returns:
        the datatype for the given path.

      • getResolvedID

        long getResolvedID​(DataType dt)
        Returns the dataTypeId for the given dataType. If the dataType is not currently in the dataTypeManger, it will be added
        Parameters:
        dt - the data type
        Returns:
        the ID of the resolved type

      • getID

        long getID​(DataType dt)
        Returns the dataTypeId for the given dataType. If the dataType does not exist, a -1 will be returned
        Parameters:
        dt - the datatype to get an id for
        Returns:
        the ID of the type

      • getDataType

        DataType getDataType​(long dataTypeID)
        Returns the dataType associated with the given dataTypeId or null if the dataTypeId is not valid
        Parameters:
        dataTypeID - the ID
        Returns:
        the type

      • getCategory

        Category getCategory​(long categoryID)
        Returns the Category with the given id
        Parameters:
        categoryID - id of the desired category
        Returns:
        the category

      • getCategory

        Category getCategory​(CategoryPath path)
        Get the category that has the given path
        Parameters:
        path - the path
        Returns:
        the category if defined, otherwise null

      • dataTypeChanged

        void dataTypeChanged​(DataType dataType,
                     boolean isAutoChange)
        Notification when data type is changed.
        Parameters:
        dataType - data type that is changed
        isAutoChange - true if change was an automatic change in response to another datatype's change (e.g., size, alignment).

      • addDataTypeManagerListener

        void addDataTypeManagerListener​(DataTypeManagerChangeListener l)
        Add a listener that is notified when the dataTypeManger changes.
        Parameters:
        l - the listener

      • removeDataTypeManagerListener

        void removeDataTypeManagerListener​(DataTypeManagerChangeListener l)
        Remove the DataTypeManger change listener.
        Parameters:
        l - the listener

      • addInvalidatedListener

        void addInvalidatedListener​(InvalidatedListener listener)
        Adds a listener that will be notified when this manager's cache is invalidated. This will happen when the system has changed and the manager cannot determine the exact change, like during an undo or a redo.
        Parameters:
        listener - The listener to add

      • removeInvalidatedListener

        void removeInvalidatedListener​(InvalidatedListener listener)
        Removes a previously added InvalidatedListener
        Parameters:
        listener - the listener to remove.

      • remove

        boolean remove​(DataType dataType,
               TaskMonitor monitor)
        Remove the given datatype from this manager
        Parameters:
        dataType - the dataType to be removed
        monitor - the task monitor
        Returns:
        true if the data type existed and was removed

      • contains

        boolean contains​(DataType dataType)
        Return true if the given dataType exists in this data type manager
        Parameters:
        dataType - the type
        Returns:
        true if the type is in this manager

      • createCategory

        Category createCategory​(CategoryPath path)
        Create a category for the given path; returns the current category if it already exits
        Parameters:
        path - the path
        Returns:
        the category

      • getDataType

        DataType getDataType​(CategoryPath path,
                     java.lang.String name)
        Gets the data type with the indicated name in the indicated category.
        Parameters:
        path - the path for the category
        name - the data type's name
        Returns:
        the data type.

      • getName

        java.lang.String getName()
        Returns this data type manager's name
        Returns:
        the name

      • setName

        void setName​(java.lang.String name)
      throws InvalidNameException
        Sets this data type manager's name
        Parameters:
        name - the new name
        Throws:
        InvalidNameException - if the given name is invalid (such as when null or empty)

      • startTransaction

        int startTransaction​(java.lang.String description)
        Starts a transaction for making changes in this data type manager.
        Parameters:
        description - a short description of the changes to be made.
        Returns:
        the transaction ID

      • isUpdatable

        boolean isUpdatable()
        Returns true if this DataTypeManager can be modified.
        Returns:
        true if this DataTypeMangaer can be modified.

      • endTransaction

        void endTransaction​(int transactionID,
                    boolean commit)
        Ends the current transaction
        Parameters:
        transactionID - id of the transaction to end
        commit - true if changes are committed, false if changes in transaction are revoked

      • flushEvents

        void flushEvents()
        Force all pending notification events to be flushed
        Throws:
        java.lang.IllegalStateException - if the client is holding this object's lock

      • close

        void close()
        Closes this dataType manager

      • getPointer

        Pointer getPointer​(DataType datatype)
        Returns a default sized pointer to the given datatype. The pointer size is established dynamically based upon the data organization established by the compiler specification.
        Parameters:
        datatype - the pointed to data type
        Returns:
        the pointer

      • getPointer

        Pointer getPointer​(DataType datatype,
                   int size)
        Returns a pointer of the given size to the given datatype. Note: It is preferred to use default sized pointers when possible (i.e., size=-1, see getPointer(DataType)) instead of explicitly specifying the size value.
        Parameters:
        datatype - the pointed to data type
        size - the size of the pointer to be created or -1 for a default sized pointer
        Returns:
        the pointer

      • getRootCategory

        Category getRootCategory()
        Returns the root category Manager
        Returns:
        the category

      • isFavorite

        boolean isFavorite​(DataType datatype)
        Returns true if the given datatype has been designated as a favorite. If the datatype does not belong to this datatype manager, then false will be returned.
        Parameters:
        datatype - the datatype to check.
        Returns:
        true if the given datatype is a favorite in this manager.

      • setFavorite

        void setFavorite​(DataType datatype,
                 boolean isFavorite)
        Sets the given dataType to be either a favorite or not a favorite.
        Parameters:
        datatype - the datatype for which to change its status as a favorite.
        isFavorite - true if the datatype is to be a favorite or false otherwise.
        Throws:
        java.lang.IllegalArgumentException - if the given datatype does not belong to this manager.

      • getFavorites

        java.util.List<DataType> getFavorites()
        Returns a list of datatypes that have been designated as favorites.
        Returns:
        the list of favorite datatypes in this manager.

      • getCategoryCount

        int getCategoryCount()
        Returns the total number of data type categories
        Returns:
        the count

      • getDataTypeCount

        int getDataTypeCount​(boolean includePointersAndArrays)
        Returns the total number of defined data types.
        Parameters:
        includePointersAndArrays - if true all pointers and array data types will be included
        Returns:
        the count

      • findEnumValueNames

        void findEnumValueNames​(long value,
                        java.util.Set<java.lang.String> enumValueNames)
        Adds all enum value names that match the given value, to the given set.
        Parameters:
        value - the value to look for enum name matches
        enumValueNames - the set to add matches to.

      • findDataTypeForID

        DataType findDataTypeForID​(UniversalID datatypeID)
        Get's the data type with the matching universal data type id.
        Parameters:
        datatypeID - The universal id of the data type to search for
        Returns:
        The data type with the matching UUID, or null if no such data type can be found.

      • getLastChangeTimeForMyManager

        long getLastChangeTimeForMyManager()
        Returns the timestamp of the last time this manager was changed
        Returns:
        the timestamp

      • getSourceArchive

        SourceArchive getSourceArchive​(UniversalID sourceID)
        Returns the source archive for the given ID
        Parameters:
        sourceID - the ID
        Returns:
        the archive; null if the ID is null; null if the archive does not exist

      • getType

        ArchiveType getType()
        Returns this manager's archive type
        Returns:
        the type

      • getDataTypes

        java.util.List<DataType> getDataTypes​(SourceArchive sourceArchive)
        Returns all data types within this manager that have as their source the given archive
        Parameters:
        sourceArchive - the archive
        Returns:
        the types

      • getLocalSourceArchive

        SourceArchive getLocalSourceArchive()
        Returns the source archive for this manager
        Returns:
        the archive; null if the ID is null; null if the archive does not exist

      • associateDataTypeWithArchive

        void associateDataTypeWithArchive​(DataType datatype,
                                  SourceArchive archive)
        Change the given data type so that its source archive is the given archive
        Parameters:
        datatype - the type
        archive - the archive

      • disassociate

        void disassociate​(DataType datatype)
        If the indicated data type is associated with a source archive, this will remove the association and the data type will become local to this data type manager.
        Parameters:
        datatype - the data type to be disassociated from a source archive.

      • updateSourceArchiveName

        boolean updateSourceArchiveName​(java.lang.String archiveFileID,
                                java.lang.String name)
        Updates the name associated with a source archive in this data type manager.
        Parameters:
        archiveFileID - Universal domain file ID of the source data type archive that has a new name.
        name - the new name of the program or archive.
        Returns:
        true if the name associated with the source data type archive was changed. false if it wasn't changed.

      • updateSourceArchiveName

        boolean updateSourceArchiveName​(UniversalID sourceID,
                                java.lang.String name)
        Updates the name associated with a source archive in this data type manager.
        Parameters:
        sourceID - Universal archive ID of the source data type archive that has a new name.
        name - the new name of the program or archive.
        Returns:
        true if the name associated with the source data type archive was changed. false if it wasn't changed.

      • getDataOrganization

        DataOrganization getDataOrganization()
        Get the data organization associated with this data type manager. Note that the DataOrganization settings may not be changed dynamically.
        Returns:
        data organization (will never be null)

      • getSourceArchives

        java.util.List<SourceArchive> getSourceArchives()
        Returns a list of source archives not including the builtin or the program's archive.
        Returns:
        a list of source archives not including the builtin or the program's archive.

      • removeSourceArchive

        void removeSourceArchive​(SourceArchive sourceArchive)
        Removes the source archive from this manager. This will disassociate all data types in this manager from the given archive.
        Parameters:
        sourceArchive - the archive

      • resolveSourceArchive

        SourceArchive resolveSourceArchive​(SourceArchive sourceArchive)
        Returns or creates a persisted version of the given source archive
        Parameters:
        sourceArchive - the archive
        Returns:
        the archive

      • getDataTypesContaining

        java.util.Set<DataType> getDataTypesContaining​(DataType dataType)
        Returns the data types within this data type manager that contain the specified data type.
        Parameters:
        dataType - the data type
        Returns:
        a set of data types that contain the specified data type.