Package ghidra.program.model.data

Class BuiltInDataTypeManager

java.lang.Object
ghidra.program.database.data.DataTypeManagerDB
ghidra.program.model.data.StandAloneDataTypeManager
ghidra.program.model.data.BuiltInDataTypeManager
All Implemented Interfaces:
DataTypeManager, Closeable, AutoCloseable
public final class BuiltInDataTypeManager extends StandAloneDataTypeManager
Data type manager for built in types that do not live anywhere except in memory.

  • Method Details

    • getDataTypeManager

      public static BuiltInDataTypeManager getDataTypeManager()
      Returns shared instance of built-in data type manager.
      Returns:
      the manager

    • setProgramArchitecture

      protected final void setProgramArchitecture(ProgramArchitecture programArchitecture, VariableStorageManager variableStorageMgr, boolean force, TaskMonitor monitor) throws IOException, CancelledException
      Description copied from class: StandAloneDataTypeManager
      Set the architecture-specific details associated with a new datatype manager. This method is intended to be used during instantiation of derived implementations.
      Overrides:
      setProgramArchitecture in class StandAloneDataTypeManager
      Parameters:
      programArchitecture - program architecture details (required)
      variableStorageMgr - variable storage manager. Must be null.
      force - 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. If true and no variable storage is specified it will be created.
      monitor - task monitor
      Throws:
      IOException - if IO error occurs
      CancelledException - if task cancelled

    • isArchitectureChangeAllowed

      protected final boolean isArchitectureChangeAllowed()
      Description copied from class: StandAloneDataTypeManager
      Determine if a program architecture change is permitted
      Overrides:
      isArchitectureChangeAllowed in class StandAloneDataTypeManager
      Returns:
      true if change allowed else false if disallowed

    • startTransaction

      public int startTransaction(String description)
      Description copied from interface: DataTypeManager
      Starts a transaction for making changes in this data type manager.
      Specified by:
      startTransaction in interface DataTypeManager
      Overrides:
      startTransaction in class StandAloneDataTypeManager
      Parameters:
      description - a short description of the changes to be made.
      Returns:
      the transaction ID

    • endTransaction

      public boolean endTransaction(int transactionID, boolean commit)
      Description copied from interface: DataTypeManager
      Ends the current transaction.

      NOTE: If multiple transactions are outstanding the full transaction will not be ended until all transactions have been ended. If any of the transactions indicate a false for commit the transaction will ultimately be rolled-back when the final transaction is ended.

      NOTE: Use of rollback (commit=false should be avoided unless absolutely neccessary since it will incur overhead to revert changes and may rollback multiple concurrent transactions if they exist.

      NOTE: If this manager is part of a larger DomainObject its transactions may become entangled with other transactions at a higher level. In such cases, use of the DomainObject transaction interface is preferred. The return value from this method cannot be relied on in such cases.

      Specified by:
      endTransaction in interface DataTypeManager
      Overrides:
      endTransaction in class StandAloneDataTypeManager
      Parameters:
      transactionID - id of the transaction to end
      commit - true if changes are committed, false if changes in transaction should be rolled back.
      Returns:
      true if this invocation was the final transaction and all changes were comitted.

    • canUndo

      public boolean canUndo()
      Description copied from class: StandAloneDataTypeManager
      Determine if there is a previous transaction that can be reverted/undone (see StandAloneDataTypeManager.undo()).
      Overrides:
      canUndo in class StandAloneDataTypeManager
      Returns:
      true if there is a previous transaction that can be reverted/undone, else false.

    • canRedo

      public boolean canRedo()
      Description copied from class: StandAloneDataTypeManager
      Determine if there is a transaction previously undone (see StandAloneDataTypeManager.undo()) that can be redone (see StandAloneDataTypeManager.redo()).
      Overrides:
      canRedo in class StandAloneDataTypeManager
      Returns:
      true if there is a transaction previously undone that can be redone, else false

    • 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
      Overrides:
      createCategory in class DataTypeManagerDB
      Parameters:
      path - the path
      Returns:
      the category

    • populateBuiltInTypes

      protected void populateBuiltInTypes()
      Add the built in data types to the default built in folder if they were not found in any other category.

    • resolveSourceArchiveID

      protected UniversalID resolveSourceArchiveID(DataType dataType)

    • getType

      public ArchiveType getType()
      Description copied from interface: DataTypeManager
      Returns this manager's archive type
      Specified by:
      getType in interface DataTypeManager
      Overrides:
      getType in class StandAloneDataTypeManager
      Returns:
      the type

    • 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
      Overrides:
      resolve in class DataTypeManagerDB
      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

      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
      Overrides:
      addDataType in class DataTypeManagerDB
      Parameters:
      originalDataType - the dataType to be resolved.
      handler - used to resolve conflicts with existing dataTypes.
      Returns:
      an equivalent dataType that "belongs" to this dataTypeManager.

    • setName

      public void setName(String name) throws InvalidNameException
      Description copied from interface: DataTypeManager
      Sets this data type manager's name
      Specified by:
      setName in interface DataTypeManager
      Overrides:
      setName in class StandAloneDataTypeManager
      Parameters:
      name - the new name
      Throws:
      InvalidNameException - if the given name is invalid (such as when null or empty)

    • 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
      Overrides:
      associateDataTypeWithArchive in class DataTypeManagerDB
      Parameters:
      datatype - the type
      archive - the archive

    • 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
      Overrides:
      remove in class DataTypeManagerDB
      Parameters:
      dataType - the dataType to be removed
      monitor - the task monitor
      Returns:
      true if the data type existed and was removed

    • 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
      Overrides:
      replaceDataType in class DataTypeManagerDB
      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;

    • close

      public void close()
      Description copied from interface: DataTypeManager
      Closes this dataType manager
      Specified by:
      close in interface AutoCloseable
      Specified by:
      close in interface Closeable
      Specified by:
      close in interface DataTypeManager
      Overrides:
      close in class StandAloneDataTypeManager