Class DataTypeManagerDB

java.lang.Object
ghidra.program.database.data.DataTypeManagerDB
All Implemented Interfaces:
DataTypeManager
Direct Known Subclasses:
ProgramBasedDataTypeManagerDB, ProjectDataTypeManager, StandAloneDataTypeManager

public abstract class DataTypeManagerDB extends Object implements DataTypeManager
Base class for DB-backed data type managers.
Important Notes:
  • Field Details

  • Constructor Details

    • DataTypeManagerDB

      protected DataTypeManagerDB(DataOrganization dataOrganization)
      Construct a new temporary data-type manager. Note that this manager does not support the save or saveAs operation.
      Parameters:
      dataOrganization - applicable data organization
    • DataTypeManagerDB

      protected DataTypeManagerDB(ResourceFile packedDBfile, int openMode) throws IOException
      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.
      Parameters:
      packedDBfile - packed datatype archive file (i.e., *.gdt resource).
      openMode - open mode CREATE, READ_ONLY or UPDATE (see DBConstants).
      Throws:
      IOException - a low-level IO error. This exception may also be thrown when a version error occurs (cause is VersionException).
    • DataTypeManagerDB

      protected DataTypeManagerDB(DBHandle handle, AddressMap addrMap, int openMode, ErrorHandler errHandler, Lock lock, TaskMonitor monitor) throws CancelledException, IOException, VersionException
      Constructor for a database-backed DataTypeManagerDB extension.
      Parameters:
      handle - database handle
      addrMap - address map (may be null)
      openMode - open mode CREATE, READ_ONLY or UPDATE (see DBConstants).
      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(int openMode, TaskMonitor monitor) throws CancelledException, IOException, VersionException
      Initialize other DB adapters after base implementation adapters has been initialized.
      Parameters:
      openMode - the DB open mode (see DBConstants)
      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.
    • 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
    • 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
    • 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
      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(CategoryPath path, String name)
      This method gets a ".conflict" name that is not currently used by any data types in the indicated category of the data type manager.
      Parameters:
      path - the category path of the category where the new data type live in the data type manager.
      name - The name of the data type. This name may or may not contain ".conflict" as part of it. If the name contains ".conflict", only the part of the name that comes prior to the ".conflict" will be used to determine a new unused conflict 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;
    • replaceDataTypeIDs

      protected abstract void replaceDataTypeIDs(long oldID, long newID)
    • 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.
      Specified by:
      findDataTypes in interface DataTypeManager
      Parameters:
      name - name of the data type
      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.
      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.
    • 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 so that its source archive is the given archive
      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)
    • deleteDataTypeIDs

      protected abstract void deleteDataTypeIDs(LinkedList<Long> deletedIds, TaskMonitor monitor) throws CancelledException
      Throws:
      CancelledException
    • 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()
    • 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
    • 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
    • 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 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 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.
    • getDataOrganization

      public 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)
    • 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(CompilerSpec compilerSpec, TaskMonitor monitor) throws CancelledException
      This method is only invoked during an upgrade.
      Parameters:
      compilerSpec - compiler spec
      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 operation is cancelled