Package ghidra.program.database.data

Class DataTypeManagerDB

java.lang.Object
ghidra.program.database.data.DataTypeManagerDB
All Implemented Interfaces:
DataTypeManager
Direct Known Subclasses:
ProgramBasedDataTypeManagerDB, StandAloneDataTypeManager
public abstract class DataTypeManagerDB extends Object implements DataTypeManager
Base class for DB-backed data type managers.
Important Notes:

  • Field Details

    • UNKNOWN_CALLING_CONVENTION_ID

      public static final byte UNKNOWN_CALLING_CONVENTION_ID
      See Also:

    • DEFAULT_CALLING_CONVENTION_ID

      public static final byte DEFAULT_CALLING_CONVENTION_ID
      See Also:

    • sourceArchiveAdapter

      protected ghidra.program.database.data.SourceArchiveAdapter sourceArchiveAdapter

    • readOnlyMode

      protected final boolean readOnlyMode

    • dbHandle

      protected final DBHandle dbHandle

    • tablePrefix

      protected final String tablePrefix

    • errHandler

      protected final ErrorHandler errHandler

    • defaultListener

      protected DataTypeManagerChangeListenerHandler defaultListener

    • universalID

      protected UniversalID universalID

    • addrMap

      protected AddressMap addrMap

    • lock

      protected final Lock lock

  • Constructor Details

    • DataTypeManagerDB

      protected DataTypeManagerDB(DataOrganization dataOrganization) throws RuntimeIOException
      Construct a new temporary data-type manager. Note that this manager does not support the save or saveAs operation. No Language is associated with instance.
      Parameters:
      dataOrganization - applicable data organization
      Throws:
      RuntimeIOException - if database error occurs during creation

    • DataTypeManagerDB

      protected DataTypeManagerDB(ResourceFile packedDBfile, OpenMode openMode, TaskMonitor monitor) throws IOException, CancelledException
      Constructor for a data-type manager backed by a packed database file. When opening for UPDATE an automatic upgrade will be performed if required. NOTE: Default DataOrganization will be used for new archive.
      Parameters:
      packedDBfile - packed datatype archive file (i.e., *.gdt resource).
      openMode - open mode CREATE, READ_ONLY or UPDATE
      monitor - task monitor
      Throws:
      IOException - a low-level IO error. This exception may also be thrown when a version error occurs (cause is VersionException).
      CancelledException - if task cancelled

    • DataTypeManagerDB

      protected DataTypeManagerDB(DBHandle handle, AddressMap addrMap, OpenMode openMode, String tablePrefix, ErrorHandler errHandler, Lock lock, TaskMonitor monitor) throws CancelledException, IOException, VersionException
      Constructor for a database-backed DataTypeManagerDB extension. NOTE: This does not check for and handle data organization changes which must be handled later (use hasDataOrganizationChange(boolean) and compilerSpecChanged(TaskMonitor) to check for and initiate response to changes).
      Parameters:
      handle - database handle
      addrMap - address map (may be null)
      openMode - open mode CREATE, READ_ONLY, UPDATE, UPGRADE.
      tablePrefix - DB table prefix to be applied to all associated table names. This need only be specified when using multiple instances with the same DB handle (null or empty string for no-prefix).
      errHandler - the error handler
      lock - database lock
      monitor - the current task monitor
      Throws:
      CancelledException - if an upgrade is cancelled
      IOException - if there is a problem reading the database
      VersionException - if any database handle's version doesn't match the expected version. This exception will never be thrown in READ_ONLY mode.

  • Method Details

    • initializeOtherAdapters

      protected void initializeOtherAdapters(OpenMode openMode, TaskMonitor monitor) throws CancelledException, IOException, VersionException
      Initialize other DB adapters after base implementation adapters has been initialized.
      Parameters:
      openMode - the DB open mode
      monitor - the progress monitor
      Throws:
      CancelledException - if the user cancels an upgrade
      VersionException - if the database does not match the expected version.
      IOException - if a database IO error occurs.

    • handleDataOrganizationChange

      protected void handleDataOrganizationChange(OpenMode openMode, TaskMonitor monitor) throws IOException, LanguageVersionException, CancelledException
      Throws:
      IOException
      LanguageVersionException
      CancelledException

    • getDataMap

      protected DBStringMapAdapter getDataMap(boolean createIfNeeded) throws IOException
      Get the manager string data map.
      Parameters:
      createIfNeeded - if true map will be created if it does not exist
      Returns:
      manager string data map or null
      Throws:
      IOException - if an IO error occurs

    • setProgramArchitecture

      protected void setProgramArchitecture(ProgramArchitecture programArchitecture, VariableStorageManager variableStorageMgr, boolean store, TaskMonitor monitor) throws IOException, CancelledException
      Set the architecture-specific details associated with this datatype manager. The data organization will be obtained from the compiler spec specified by the program architecture. Fixup of all composites will be performed, if store is true, to reflect any changes in the data organization. The caller is resposible for ensuring that this setting is done consistent with the addrMap setting used during construction if applicable.
      If not storing caller may need to check for data organization change to communicate change or to facilitate an upgrade situation.
      Parameters:
      programArchitecture - program architecture details (may be null) in which case default data organization will be used.
      variableStorageMgr - variable storage manager (within same database) or null to disable variable storage support. Ignored if programArchitecture is null;
      store - if true database update will occur and datatypes will be updated if any change to the data organization is detected (a stored copy may be used to detect this condition). This should never be passed as true if opened read-only. This should be false during create mode where only the state is affected without changing the Database or existing datatypes.
      monitor - task monitor
      Throws:
      IOException - if IO error occurs
      CancelledException - if processing cancelled - data types may not properly reflect updated compiler specification
      javax.help.UnsupportedOperationException - if language was previously set

    • compilerSpecChanged

      protected void compilerSpecChanged(TaskMonitor monitor) throws IOException, CancelledException
      Perform updates related to a compiler spec change, including:
      • data organization changes which may impact datatype components and packing
      NOTE: this manager must be open for update.
      Parameters:
      monitor - task monitor
      Throws:
      ReadOnlyException - if this manager has not been open for update
      IOException - if an IO error occurs while performing updates
      CancelledException - if processing cancelled - data types may not properly reflect updated compiler specification

    • hasDataOrganizationChange

      protected final boolean hasDataOrganizationChange(boolean ifPreviouslyStored) throws IOException
      Check if the active getDataOrganization() differs from the stored data organization. False will be returned when ifPreviouslyStored is true and data organization has never beeen saved.
      Parameters:
      ifPreviouslyStored - if true and data organization has never been saved false will be returned
      Returns:
      true if a data organization change has occured
      Throws:
      IOException - if an IO error occurs

    • saveDataOrganization

      protected void saveDataOrganization() throws IOException
      Save the current data organization to facilitate future change detection and upgrades.
      Throws:
      IOException - if failure occured while saving data organization.

    • readDataOrganization

      protected DataOrganization readDataOrganization() throws IOException
      Read the DB-serialized data organization. If one has not been stored a suitable default will be returned.
      Returns:
      stored data organization or suitable default.
      Throws:
      IOException - if DB error orccurs

    • getProgramArchitecture

      public ProgramArchitecture getProgramArchitecture()
      Description copied from interface: DataTypeManager
      Get the optional program architecture details associated with this archive
      Specified by:
      getProgramArchitecture in interface DataTypeManager
      Returns:
      program architecture details or null if none

    • getProgramArchitectureSummary

      protected static String getProgramArchitectureSummary(LanguageID languageId, int languageVersion, CompilerSpecID compilerSpecId)

    • getProgramArchitectureSummary

      public String getProgramArchitectureSummary()
      Description copied from interface: DataTypeManager
      Get the program architecture information which has been associated with this datatype manager. If DataTypeManager.getProgramArchitecture() returns null this method may still return information if the program architecture was set on an archive but unable to properly instantiate.
      Specified by:
      getProgramArchitectureSummary in interface DataTypeManager
      Returns:
      program architecture summary if it has been set

    • getVariableStorageManager

      protected VariableStorageManager getVariableStorageManager()
      Get the variable storage manager if it has been established.
      Returns:
      variable storage manager or null if no associated architecture.

    • isTransactionActive

      protected final boolean isTransactionActive()
      Determine if transaction is active. With proper lock established this method may be useful for determining if a lazy record update may be performed.
      Returns:
      true if database transaction if active, else false

    • notifyRestored

      public void notifyRestored()
      This method should be invoked following an undo/redo or a transaction rollback situation. This will notify DataTypeManagerChangeListenerHandler and its listeners that this manager has just been restored (e.g., undo/redo/rollback).

    • getDomainFileID

      protected abstract String getDomainFileID()

    • getPath

      protected abstract String getPath()

    • getUniversalID

      public UniversalID getUniversalID()
      Description copied from interface: DataTypeManager
      Returns the universal ID for this dataType manager
      Specified by:
      getUniversalID in interface DataTypeManager
      Returns:
      the universal ID for this dataType manager

    • updateID

      public void updateID()

    • getFavorites

      public List<DataType> getFavorites()
      Description copied from interface: DataTypeManager
      Returns a list of datatypes that have been designated as favorites.
      Specified by:
      getFavorites in interface DataTypeManager
      Returns:
      the list of favorite datatypes in this manager.

    • isFavorite

      public boolean isFavorite(DataType dataType)
      Description copied from interface: DataTypeManager
      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.
      Specified by:
      isFavorite in interface DataTypeManager
      Parameters:
      dataType - the datatype to check.
      Returns:
      true if the given datatype is a favorite in this manager.

    • setFavorite

      public void setFavorite(DataType dataType, boolean isFavorite)
      Description copied from interface: DataTypeManager
      Sets the given dataType to be either a favorite or not a favorite.
      Specified by:
      setFavorite in interface DataTypeManager
      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.

    • getUniqueName

      public String getUniqueName(CategoryPath path, String baseName)
      Description copied from interface: DataTypeManager
      Returns a unique name not currently used by any other dataType or category with the same baseName. This does not produce a conflict name and is intended to be used when generating an artifical datatype name only (e.g., temp_1, temp_2; for baseName="temp".
      Specified by:
      getUniqueName in interface DataTypeManager
      Parameters:
      path - the path of the name
      baseName - the base name to be made unique
      Returns:
      a unique name starting with baseName

    • getCategory

      public Category getCategory(CategoryPath path)
      Description copied from interface: DataTypeManager
      Get the category that has the given path
      Specified by:
      getCategory in interface DataTypeManager
      Parameters:
      path - the path
      Returns:
      the category if defined, otherwise null

    • getCategory

      public Category getCategory(long id)
      Get the category for the given ID.
      Specified by:
      getCategory in interface DataTypeManager
      Parameters:
      id - id of the desired category
      Returns:
      null if no category exists with the given ID.

    • resolve

      public DataType resolve(DataType dataType, DataTypeConflictHandler handler)
      Description copied from interface: DataTypeManager
      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.
      Specified by:
      resolve in interface DataTypeManager
      Parameters:
      dataType - the dataType to be resolved.
      handler - used to resolve conflicts with existing dataTypes.
      Returns:
      an equivalent dataType that "belongs" to this dataTypeManager.

    • getUnusedConflictName

      public String getUnusedConflictName(DataType dt)
      This method gets a ".conflict" name that is not currently used by any data types in the datatype's category within this data type manager. If the baseName without conflict suffix is not used that name will be returned.
      NOTE: The original datatype name will be returned unchanged for pointers and arrays since they cannot be renamed.
      Parameters:
      dt - datatype who name is used to establish non-conflict base name
      Returns:
      the unused conflict name or original name for datatypes whose name is automatic

    • getUnusedConflictName

      public String getUnusedConflictName(CategoryPath path, DataType dt)
      This method gets a ".conflict" name that is not currently used by any data types in the indicated category within this data type manager. If the baseName without conflict suffix is not used that name will be returned.
      NOTE: The original datatype name will be returned unchanged for pointers and arrays since they cannot be renamed.
      NOTE: Otherwise, if category does not exist the non-conflict name will be returned.
      Parameters:
      path - the category path of the category where the new data type live in the data type manager.
      dt - datatype who name is used to establish non-conflict base name
      Returns:
      the unused conflict name

    • addDataType

      public DataType addDataType(DataType originalDataType, DataTypeConflictHandler handler)
      Description copied from interface: DataTypeManager
      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.
      Specified by:
      addDataType in interface DataTypeManager
      Parameters:
      originalDataType - the dataType to be resolved.
      handler - used to resolve conflicts with existing dataTypes.
      Returns:
      an equivalent dataType that "belongs" to this dataTypeManager.

    • addDataTypes

      public void addDataTypes(Collection<DataType> dataTypes, DataTypeConflictHandler handler, TaskMonitor monitor) throws CancelledException
      Description copied from interface: DataTypeManager
      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.
      Specified by:
      addDataTypes in interface DataTypeManager
      Parameters:
      dataTypes - collection of datatypes
      handler - conflict handler
      monitor - task monitor
      Throws:
      CancelledException - if monitor is cancelled

    • resolveSourceArchive

      public SourceArchive resolveSourceArchive(SourceArchive sourceArchive)
      Description copied from interface: DataTypeManager
      Returns or creates a persisted version of the given source archive
      Specified by:
      resolveSourceArchive in interface DataTypeManager
      Parameters:
      sourceArchive - the archive
      Returns:
      the archive

    • removeSourceArchive

      public void removeSourceArchive(SourceArchive sourceArchive)
      Description copied from interface: DataTypeManager
      Removes the source archive from this manager. This will disassociate all data types in this manager from the given archive.
      Specified by:
      removeSourceArchive in interface DataTypeManager
      Parameters:
      sourceArchive - the archive

    • replaceDataType

      public DataType replaceDataType(DataType existingDt, DataType replacementDt, boolean updateCategoryPath) throws DataTypeDependencyException
      Description copied from interface: DataTypeManager
      Replace an existing dataType with another. All instances and references will be updated to use the replacement dataType.
      Specified by:
      replaceDataType in interface DataTypeManager
      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;

    • replaceDataTypesUsed

      protected abstract void replaceDataTypesUsed(Map<Long,Long> dataTypeReplacementMap)
      Allow extensions to perform any neccessary fixups to address all datatype replacements.
      Parameters:
      dataTypeReplacementMap - map of datatype replacements (oldID maps to replacementID).

    • replaceSourceArchive

      public void replaceSourceArchive(SourceArchive oldSourceArchive, SourceArchive newSourceArchive)
      Replace one source archive (oldDTM) with another (newDTM). Any data types whose source was the oldDTM will be changed to have a source that is the newDTM. The oldDTM will no longer be referenced as a source by this data type manager.
      Parameters:
      oldSourceArchive - data type manager for the old source archive
      newSourceArchive - data type manager for the new source archive
      Throws:
      IllegalArgumentException - if the oldDTM isn't currently a source archive for this data type manager or if the old and new source archives already have the same unique ID.

    • findDataTypes

      public void findDataTypes(String name, List<DataType> list)
      Description copied from interface: DataTypeManager
      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. Presence of .conflict extension will be ignored for both specified name and returned results.
      Specified by:
      findDataTypes in interface DataTypeManager
      Parameters:
      name - name of the data type (wildcards are not supported and will be treated as explicit search characters)
      list - list that will be populated with matching DataType objects

    • findDataTypes

      public void findDataTypes(String name, List<DataType> list, boolean caseSensitive, TaskMonitor monitor)
      Description copied from interface: DataTypeManager
      Begin searching at the root category for all data types with names that match the given name that may contain wildcards using familiar globbing characters '*' and '?'.
      Specified by:
      findDataTypes in interface DataTypeManager
      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

    • getDataType

      public DataType getDataType(DataTypePath dataTypePath)
      Description copied from interface: DataTypeManager
      Find the dataType for the given dataTypePath.
      Specified by:
      getDataType in interface DataTypeManager
      Parameters:
      dataTypePath - the DataTypePath for the datatype
      Returns:
      the datatype for the given path.

    • getDataType

      public DataType getDataType(String dataTypePath)
      Description copied from interface: DataTypeManager
      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 DataTypeManager.getDataType(DataTypePath) method because the DataTypePath keeps the category and datatype name separate.
      Specified by:
      getDataType in interface DataTypeManager
      Parameters:
      dataTypePath - path
      Returns:
      the dataType or null if it isn't found

    • findDataType

      public DataType findDataType(String dataTypePath)
      Description copied from interface: DataTypeManager
      Gets the dataType for the given path. See DataTypeManager.getDataType(String) for details.
      Specified by:
      findDataType in interface DataTypeManager
      Parameters:
      dataTypePath - dataType path
      Returns:
      dataType at the given path

    • findEnumValueNames

      public void findEnumValueNames(long value, Set<String> enumValueNames)
      Description copied from interface: DataTypeManager
      Adds all enum value names that match the given value, to the given set.
      Specified by:
      findEnumValueNames in interface DataTypeManager
      Parameters:
      value - the value to look for enum name matches
      enumValueNames - the set to add matches to.

    • getResolvedID

      public long getResolvedID(DataType dt)
      Description copied from interface: DataTypeManager
      Returns the dataTypeId for the given dataType. If the dataType is not currently in the dataTypeManger, it will be added
      Specified by:
      getResolvedID in interface DataTypeManager
      Parameters:
      dt - the data type
      Returns:
      the ID of the resolved type

    • getID

      public long getID(DataType dt)
      Description copied from interface: DataTypeManager
      Returns the dataTypeId for the given dataType. If the dataType does not exist, a -1 will be returned
      Specified by:
      getID in interface DataTypeManager
      Parameters:
      dt - the datatype to get an id for
      Returns:
      the ID of the type

    • getDataType

      public DataType getDataType(long dataTypeID)
      Description copied from interface: DataTypeManager
      Returns the dataType associated with the given dataTypeId or null if the dataTypeId is not valid
      Specified by:
      getDataType in interface DataTypeManager
      Parameters:
      dataTypeID - the ID
      Returns:
      the type

    • addInvalidatedListener

      public void addInvalidatedListener(InvalidatedListener listener)
      Description copied from interface: DataTypeManager
      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.
      Specified by:
      addInvalidatedListener in interface DataTypeManager
      Parameters:
      listener - The listener to add

    • removeInvalidatedListener

      public void removeInvalidatedListener(InvalidatedListener listener)
      Description copied from interface: DataTypeManager
      Removes a previously added InvalidatedListener
      Specified by:
      removeInvalidatedListener in interface DataTypeManager
      Parameters:
      listener - the listener to remove.

    • deleteDataTypesUsed

      protected abstract void deleteDataTypesUsed(Set<Long> deletedIds)
      Allow extensions to perform any neccessary fixups for all datatype removals listed.
      Parameters:
      deletedIds - list of IDs for all datatypes which are getting removed.

    • remove

      public boolean remove(DataType dataType, TaskMonitor monitor)
      Description copied from interface: DataTypeManager
      Remove the given datatype from this manager
      Specified by:
      remove in interface DataTypeManager
      Parameters:
      dataType - the dataType to be removed
      monitor - the task monitor
      Returns:
      true if the data type existed and was removed

    • associateDataTypeWithArchive

      public void associateDataTypeWithArchive(DataType datatype, SourceArchive archive)
      Description copied from interface: DataTypeManager
      Change the given data type and its dependencies so thier source archive is set to given archive. Only those data types not already associated with a source archive will be changed.
      Specified by:
      associateDataTypeWithArchive in interface DataTypeManager
      Parameters:
      datatype - the type
      archive - the archive

    • disassociate

      public void disassociate(DataType dataType)
      Description copied from interface: DataTypeManager
      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.
      Specified by:
      disassociate in interface DataTypeManager
      Parameters:
      dataType - the data type to be disassociated from a source archive.

    • addDataTypeToDelete

      protected void addDataTypeToDelete(long id)
      Queue a datatype to deleted in response to another datatype being deleted.
      Parameters:
      id - datatype ID to be removed

    • addDataTypeToReplace

      protected void addDataTypeToReplace(DataType oldDataType, DataType replacementDataType)
      Queue a datatype to be replaced by another datatype in response to its referenced datatype being replaced.
      Parameters:
      oldDataType - datatype to be replaced
      replacementDataType - datatype which is the replacement

    • contains

      public boolean contains(DataType dataType)
      Description copied from interface: DataTypeManager
      Return true if the given dataType exists in this data type manager
      Specified by:
      contains in interface DataTypeManager
      Parameters:
      dataType - the type
      Returns:
      true if the type is in this manager

    • containsCategory

      public boolean containsCategory(CategoryPath path)
      Description copied from interface: DataTypeManager
      Returns true if the given category path exists in this datatype manager
      Specified by:
      containsCategory in interface DataTypeManager
      Parameters:
      path - the path
      Returns:
      true if the given category path exists in this datatype manager

    • createCategory

      public Category createCategory(CategoryPath path)
      Description copied from interface: DataTypeManager
      Create a category for the given path; returns the current category if it already exits
      Specified by:
      createCategory in interface DataTypeManager
      Parameters:
      path - the path
      Returns:
      the category

    • getRootCategory

      public Category getRootCategory()
      Description copied from interface: DataTypeManager
      Returns the root category Manager
      Specified by:
      getRootCategory in interface DataTypeManager
      Returns:
      the category

    • getDataTypes

      public DataType[] getDataTypes(CategoryPath path)
      Gets the datatypes in the given category path
      Parameters:
      path - the category path in which to look for datatypes
      Returns:
      array of datatypes contained with specified category

    • getDataType

      public DataType getDataType(CategoryPath path, String name)
      Description copied from interface: DataTypeManager
      Gets the data type with the indicated name in the indicated category.
      Specified by:
      getDataType in interface DataTypeManager
      Parameters:
      path - the path for the category
      name - the data type's name
      Returns:
      the data type.

    • getCategoryCount

      public int getCategoryCount()
      Description copied from interface: DataTypeManager
      Returns the total number of data type categories
      Specified by:
      getCategoryCount in interface DataTypeManager
      Returns:
      the count

    • getDataTypeCount

      public int getDataTypeCount(boolean includePointersAndArrays)
      Description copied from interface: DataTypeManager
      Returns the total number of defined data types.
      Specified by:
      getDataTypeCount in interface DataTypeManager
      Parameters:
      includePointersAndArrays - if true all pointers and array data types will be included
      Returns:
      the count

    • isChanged

      public boolean isChanged()

    • updateLastChangeTime

      protected void updateLastChangeTime()

    • getSourceArchives

      public List<SourceArchive> getSourceArchives()
      Description copied from interface: DataTypeManager
      Returns a list of source archives not including the builtin or the program's archive.
      Specified by:
      getSourceArchives in interface DataTypeManager
      Returns:
      a list of source archives not including the builtin or the program's archive.

    • getSourceArchive

      public SourceArchive getSourceArchive(String fileID)

    • getSourceArchive

      public SourceArchive getSourceArchive(UniversalID sourceID)
      Description copied from interface: DataTypeManager
      Returns the source archive for the given ID
      Specified by:
      getSourceArchive in interface DataTypeManager
      Parameters:
      sourceID - the ID
      Returns:
      the archive; null if the ID is null; null if the archive does not exist

    • getLocalSourceArchive

      public SourceArchive getLocalSourceArchive()
      Description copied from interface: DataTypeManager
      Returns the source archive for this manager
      Specified by:
      getLocalSourceArchive in interface DataTypeManager
      Returns:
      the archive; null if the ID is null; null if the archive does not exist

    • updateSourceArchiveName

      public boolean updateSourceArchiveName(String archiveFileID, String name)
      Description copied from interface: DataTypeManager
      Updates the name associated with a source archive in this data type manager.
      Specified by:
      updateSourceArchiveName in interface DataTypeManager
      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

      public boolean updateSourceArchiveName(UniversalID sourceID, String name)
      Description copied from interface: DataTypeManager
      Updates the name associated with a source archive in this data type manager.
      Specified by:
      updateSourceArchiveName in interface DataTypeManager
      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.

    • getDataTypes

      public List<DataType> getDataTypes(SourceArchive sourceArchive)
      Description copied from interface: DataTypeManager
      Returns all data types within this manager that have as their source the given archive
      Specified by:
      getDataTypes in interface DataTypeManager
      Parameters:
      sourceArchive - the archive
      Returns:
      the types

    • dbError

      public void dbError(IOException e)
      Handles IOExceptions
      Parameters:
      e - the exception to handle

    • getAllDataTypes

      public Iterator<DataType> getAllDataTypes()
      Description copied from interface: DataTypeManager
      Returns an iterator over all the dataTypes in this manager
      Specified by:
      getAllDataTypes in interface DataTypeManager
      Returns:
      an iterator over all the dataTypes in this manager

    • getAllDataTypes

      public void getAllDataTypes(List<DataType> list)
      Description copied from interface: DataTypeManager
      Adds all data types to the specified list.]
      Specified by:
      getAllDataTypes in interface DataTypeManager
      Parameters:
      list - the result list into which the types will be placed

    • getAllFunctionDefinitions

      public Iterator<FunctionDefinition> getAllFunctionDefinitions()
      Description copied from interface: DataTypeManager
      Returns an iterator over all function definition data types in this manager
      Specified by:
      getAllFunctionDefinitions in interface DataTypeManager
      Returns:
      the iterator

    • getAllStructures

      public Iterator<Structure> getAllStructures()
      Description copied from interface: DataTypeManager
      Returns an iterator over all structures in this manager
      Specified by:
      getAllStructures in interface DataTypeManager
      Returns:
      the iterator

    • getAllComposites

      public Iterator<Composite> getAllComposites()
      Description copied from interface: DataTypeManager
      Returns an iterator over all composite data types (structures and unions) in this manager
      Specified by:
      getAllComposites in interface DataTypeManager
      Returns:
      the iterator

    • dispose

      public void dispose()

    • close

      public void close()
      Description copied from interface: DataTypeManager
      Closes this dataType manager
      Specified by:
      close in interface DataTypeManager

    • invalidateCache

      public void invalidateCache()
      Invalidates the cache.

    • isUpdatable

      public boolean isUpdatable()
      Description copied from interface: DataTypeManager
      Returns true if this DataTypeManager can be modified.
      Specified by:
      isUpdatable in interface DataTypeManager
      Returns:
      true if this DataTypeMangaer can be modified.

    • allowsDefaultBuiltInSettings

      public boolean allowsDefaultBuiltInSettings()
      Description copied from interface: DataTypeManager
      Determine if settings are supported for BuiltIn datatypes within this datatype manager.
      Specified by:
      allowsDefaultBuiltInSettings in interface DataTypeManager
      Returns:
      true if BuiltIn Settings are permitted

    • allowsDefaultComponentSettings

      public final boolean allowsDefaultComponentSettings()
      Description copied from interface: DataTypeManager
      Determine if settings are supported for datatype components within this datatype manager (i.e., for structure and union components).
      Specified by:
      allowsDefaultComponentSettings in interface DataTypeManager
      Returns:
      true if BuiltIn Settings are permitted

    • removeParentChildRecord

      protected void removeParentChildRecord(long parentID, long childID)

    • getChildIds

      protected Set<Long> getChildIds(long parentID)

    • hasParent

      protected boolean hasParent(long childID)

    • getDataTypesContaining

      public Set<DataType> getDataTypesContaining(DataType dataType)
      Description copied from interface: DataTypeManager
      Returns the data types within this data type manager that contain the specified data type. The specified dataType must belong to this datatype manager. An empty set will be returned for unsupported datatype instances.
      Specified by:
      getDataTypesContaining in interface DataTypeManager
      Parameters:
      dataType - the data type
      Returns:
      a set of data types that contain the specified data type.

    • getPointer

      public final Pointer getPointer(DataType dt)
      Description copied from interface: DataTypeManager
      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.
      Specified by:
      getPointer in interface DataTypeManager
      Parameters:
      dt - the pointed to data type
      Returns:
      the pointer

    • getPointer

      public final Pointer getPointer(DataType dt, int size)
      Description copied from interface: DataTypeManager
      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 DataTypeManager.getPointer(DataType)) instead of explicitly specifying the size value.
      Specified by:
      getPointer in interface DataTypeManager
      Parameters:
      dt - the pointed to data type
      size - the size of the pointer to be created or -1 for a default sized pointer
      Returns:
      the pointer

    • addDataTypeManagerListener

      public void addDataTypeManagerListener(DataTypeManagerChangeListener l)
      Description copied from interface: DataTypeManager
      Add a listener that is notified when the dataTypeManger changes.
      Specified by:
      addDataTypeManagerListener in interface DataTypeManager
      Parameters:
      l - the listener

    • removeDataTypeManagerListener

      public void removeDataTypeManagerListener(DataTypeManagerChangeListener l)
      Description copied from interface: DataTypeManager
      Remove the DataTypeManger change listener.
      Specified by:
      removeDataTypeManagerListener in interface DataTypeManager
      Parameters:
      l - the listener

    • isCreatingDataType

      protected boolean isCreatingDataType()
      Returns:
      true if manager is in the process of adding/creating a new type

    • dataTypeChanged

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

    • dataTypeSettingsChanged

      public void dataTypeSettingsChanged(DataType dt)
      Notification when data type settings have changed.
      Parameters:
      dt - data type that is changed

    • dataTypeAdded

      protected void dataTypeAdded(DataType newDt, DataType originalDataType)

    • dataTypeReplaced

      protected void dataTypeReplaced(long existingDtID, DataTypePath replacedDataTypePath, DataType replacementDt)

    • dataTypeDeleted

      protected void dataTypeDeleted(long deletedID, DataTypePath deletedDataTypePath)

    • dataTypeMoved

      protected void dataTypeMoved(DataType dt, DataTypePath oldDataTypePath, DataTypePath newDataTypePath)

    • dataTypeNameChanged

      protected void dataTypeNameChanged(DataType dt, String oldName)

    • categoryCreated

      protected void categoryCreated(Category cat)

    • categoryRenamed

      protected void categoryRenamed(CategoryPath oldPath, Category category)

    • categoryRemoved

      protected void categoryRemoved(Category parent, String name, long categoryID)

    • categoryMoved

      protected void categoryMoved(CategoryPath oldPath, Category category)

    • favoritesChanged

      protected void favoritesChanged(DataType dataType, boolean isFavorite)

    • sourceArchiveChanged

      public void sourceArchiveChanged(UniversalID sourceArchiveID)

    • sourceArchiveAdded

      protected void sourceArchiveAdded(UniversalID sourceArchiveID)

    • getLastChangeTimeForMyManager

      public long getLastChangeTimeForMyManager()
      Description copied from interface: DataTypeManager
      Returns the timestamp of the last time this manager was changed
      Specified by:
      getLastChangeTimeForMyManager in interface DataTypeManager
      Returns:
      the timestamp

    • getDataType

      public DataType getDataType(SourceArchive sourceArchive, UniversalID datatypeID)
      Description copied from interface: DataTypeManager
      Finds the data type using the given source archive and id.
      Specified by:
      getDataType in interface DataTypeManager
      Parameters:
      sourceArchive - the optional source archive; required when the type is associated with that source archive
      datatypeID - the type's id
      Returns:
      the type or null

    • findDataTypeForID

      public DataType findDataTypeForID(UniversalID datatypeID)
      Description copied from interface: DataTypeManager
      Get's the data type with the matching universal data type id.
      Specified by:
      findDataTypeForID in interface DataTypeManager
      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.

    • getAddressMap

      public AddressMap getAddressMap()
      Description copied from interface: DataTypeManager
      Returns the associated AddressMap used by this datatype manager.
      Specified by:
      getAddressMap in interface DataTypeManager
      Returns:
      the AddressMap used by this datatype manager or null if one has not be established.

    • getDataOrganization

      public final DataOrganization getDataOrganization()
      Description copied from interface: DataTypeManager
      Get the data organization associated with this data type manager. Note that the DataOrganization settings may not be changed dynamically.
      Specified by:
      getDataOrganization in interface DataTypeManager
      Returns:
      data organization (will never be null)

    • getCallingConventionName

      public String getCallingConventionName(byte id)
      Get calling convention name corresponding to existing specified id.
      Parameters:
      id - calling convention ID
      Returns:
      calling convention name if found else unknown

    • getCallingConventionID

      public byte getCallingConventionID(String name, boolean restrictive) throws InvalidInputException, IOException
      Get (and assign if needed thus requiring open transaction) the ID associated with the specified calling convention name. If name is a new convention and the number of stored convention names exceeds 127 the returned ID will correspond to the unknown calling convention.
      Parameters:
      name - calling convention name
      restrictive - if true an error will be thrown if name is not defined by GenericCallingConvention or the associated compiler specification if datatype manager has an associated program architecture.
      Returns:
      calling convention ID
      Throws:
      IOException - if database IO error occurs
      InvalidInputException - if restrictive is true and name is not defined by GenericCallingConvention or the associated compiler specification if datatype manager has an associated program architecture.

    • getDefinedCallingConventionNames

      public Collection<String> getDefinedCallingConventionNames()
      Description copied from interface: DataTypeManager
      Get the ordered list of defined calling convention names. The reserved names "unknown" and "default" are not included. The returned collection may not include all names referenced by various functions and function-definitions. This set is generally limited to those defined by the associated compiler specification. If this instance does not have an assigned architecture the GenericCallingConvention names will be returned.

      For a set of all known names (including those that are not defined by compiler spec) see DataTypeManager.getKnownCallingConventionNames().

      Specified by:
      getDefinedCallingConventionNames in interface DataTypeManager
      Returns:
      the set of defined calling convention names.

    • getKnownCallingConventionNames

      public Collection<String> getKnownCallingConventionNames()
      Description copied from interface: DataTypeManager
      Get the ordered list of known calling convention names. The reserved names "unknown" and "default" are not included. The returned collection will include all names ever used or resolved by associated Function and FunctionDefinition objects, even if not currently defined by the associated CompilerSpec or Program SpecExtension. To get only those calling conventions formally defined, the method CompilerSpec.getCallingConventions() should be used.
      Specified by:
      getKnownCallingConventionNames in interface DataTypeManager
      Returns:
      all known calling convention names.

    • getDefaultCallingConvention

      public PrototypeModel getDefaultCallingConvention()
      Description copied from interface: DataTypeManager
      Get the default calling convention's prototype model in this datatype manager if known.
      Specified by:
      getDefaultCallingConvention in interface DataTypeManager
      Returns:
      the default calling convention prototype model or null.

    • getCallingConvention

      public PrototypeModel getCallingConvention(String name)
      Description copied from interface: DataTypeManager
      Get the prototype model of the calling convention with the specified name from the associated compiler specification. If an architecture has not been established this method will return null. If Function.DEFAULT_CALLING_CONVENTION_STRING is specified DataTypeManager.getDefaultCallingConvention() will be returned.
      Specified by:
      getCallingConvention in interface DataTypeManager
      Parameters:
      name - the calling convention name
      Returns:
      the named function calling convention prototype model or null.

    • migrateOldFlexArrayComponentsIfRequired

      protected void migrateOldFlexArrayComponentsIfRequired(TaskMonitor monitor) throws IOException, CancelledException
      During any UPGRADE instantiation this method should be invoked with an open transaction once the associated DomainObject is ready. This late stage upgrade is required since it may entail resolving new array datatypes which requires this manager to be in a fully functional state.
      Parameters:
      monitor - task monitor
      Throws:
      IOException - if an IO error occurs on database
      CancelledException - if monitor is cancelled

    • doSourceArchiveUpdates

      protected void doSourceArchiveUpdates(TaskMonitor monitor) throws CancelledException
      This method is only invoked during an upgrade.
      Parameters:
      monitor - task monitor
      Throws:
      CancelledException - if task cancelled

    • fixupComposites

      public void fixupComposites(TaskMonitor monitor) throws CancelledException
      Fixup all composites and thier components which may be affected by a data organization change include primitive type size changes and alignment changes. It is highly recommended that this program be open with exclusive access before invoking this method to avoid excessive merge conflicts with other users.
      Parameters:
      monitor - task monitor
      Throws:
      CancelledException - if processing cancelled - data types may not properly reflect updated compiler specification

    • dedupeConflicts

      public boolean dedupeConflicts(DataType dataType)
      De-duplicate equivalent conflict datatypes which share a common base data type name and are found to be equivalent.
      Parameters:
      dataType - data type whose related conflict types should be de-duplicated
      Returns:
      true if one or more datatypes were de-duplicted or dde-conflicted, else false

    • dedupeAllConflicts

      public void dedupeAllConflicts(TaskMonitor monitor) throws CancelledException
      De-duplicate equivalent conflict datatypes which share a common base data type name and are found to be equivalent.
      Parameters:
      monitor - task monitor
      Throws:
      CancelledException - if task is cancelled