PamDataBlock

java.lang.Object
- PamguardMVC.PamObservable
- - PamguardMVC.PamDataBlock<Tunit>

All Implemented Interfaces:

PanelOverlayDraw

Direct Known Subclasses:

AcousticDataBlock, AISDataBlock, AlarmDataBlock, AngleDataBlock, ArrayAccelDataBlock, AutecDataBlock, BeakedDataBlock, BeakedExperimentDataBlock, BuoyStatusDataBlock, ClipDisplayDataBlock, ClipSpectrogramMarkDataBlock, D3DataBlock, DbHtDataBlock, DepthDataBlock, DStrDataBlock, FormsDataBlock, GPSDataBlock, HydrophoneDataBlock, IMUDataBlock, LandmarkDataBlock, MapCommentDataBlock, MarkDataBlock, NMEADataBlock, NoiseDataBlock, NoiseDataBlock, OfflineEventDataBlock, OneBandDataBlock, RoccaContourDataBlock, RoccaLoggingDataBlock, RoccaSightingDataBlock, SerialDataBlock, SimObjectsDataBlock, SimSoundDataBlock, SingletonDataBlock, SMLStatusDataBlock, StaticLocaliserDataBlock, StreamerDataBlock, TargetMotionDataBlock, TideDataBlock, TrackedGroupDataBlock, VRDataBlock, WhistleClasificationDataBlock
```
public class PamDataBlock<Tunit extends PamDataUnit>
extends PamObservable
```
Author:

Doug Gillespie
PamDataBlocks manage the data from PamProcesses.
New data, either from external sources (sound cards, GPS, etc.) or detector output (clicks or whistles, etc.) are placed in PamDataUnits. The job of a PamDataBlock is to manage those PamDataUnits.
Processes that require the data from a PamDataBlock must implement PamObserver and subscribe as listeners to the PamDataBlock. When a new PamDataUnit is added to a data block, all listeners will be notified and sent references both to the data block and the data unit.
Each PamDatablock is also responsible for deleting old data. Since only the observers of PamDataBlocks know how much historical data is required, before deleting any data each PamDataBlock asks all the PamObservers for their required data history in milliseconds and takes the maximum value returned by all observers. The PamDataBlock will then calculate the time of the first required data unit and delete all preceding units. This operation takes place approximately once per second.
For example, a whistle detector, while searching for whistles, may only require the last two or three data units from the data block containing FFT data, but when it's found a complete whistle, it may need to go back and look at the FFT data from other channels in order to calculate a location, or it may require the raw data in order to look at the original waveform. As another example, the map panel may want to hold several hours of data in memory for display purposes.
It is essential that PamProcesses are realistic about how much data they can ask a PamDataBlock to hold - if they consistently ask for too much data to be stored, the computer will run out of memory.

See Also:
PamDataUnit, PamProcess

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`ITERATOR_END`
`static int`	`MATCH_AFTER` If there is not exact time match, set the iterator so that the first element it returns will be the element after the requested time.
`static int`	`MATCH_BEFORE` If there is not exact time match, set the iterator so that the first element it returns will be the element before the requested time.
`static int`	`MATCH_EXACT` Only accept an iterator for a unit that matches the time exactly
`static int`	`MIX_DONOTHING`
`static int`	`MIX_INTODATABASE`
`static int`	`MIX_OUTOFDATABASE`
`static int`	`NOTIFY_NEW_DATA`
`static int`	`NOTIFY_UPDATE_DATA`
`static int`	`OFFLINE_DATA_CANCEL`
`static int`	`OFFLINE_DATA_INTERRUPT`
`static int`	`OFFLINE_DATA_WAIT`
`java.lang.Object`	`orderLock`
`static int`	`POSITION_AFTER` Set the iterator so that a call to next() will give the first wanted element
`static int`	`POSITION_BEFORE` Set the iterator so that a call to previous() will give the first wanted element
`static int`	`REFERENCE_ABSOLUTE` When getting a DataUnit from the Datablock, get the absolute data unit, i.e.
`static int`	`REFERENCE_CURRENT` When getting a DataUnit from the Datablock, get the current data unit, i.e.
`static int`	`REQUEST_DATA_LOADED` Data loaded for requested time period.
`static int`	`REQUEST_DATA_PARTIAL_LOAD` Data partially loaded for requested time period
`static int`	`REQUEST_EXCEPTION` The request threw an exception of some sort.
`static int`	`REQUEST_INTERRUPTED` The request was interrupted (in multi thread load)
`static int`	`REQUEST_NO_DATA` No data available for offline loading.
`static int`	`REQUEST_SAME_REQUEST` this is exactly the same data as requested last time.

Constructor Summary

Constructors
Constructor and Description
`PamDataBlock(java.lang.Class unitClass, java.lang.String dataName, PamProcess parentProcess, int channelMap)` PamDataBlock constructor.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addDataAnnotationType(DataAnnotationType dataAnnotationType)` Add a data annotation type to a datablock.
`void`	`addLocalisationContents(int localisationContents)`
`void`	`addObserver(PamObserver o)` Adds a PamObserver, which will then receive notifications when data is added.
`void`	`addObserver(PamObserver o, boolean reThread)`
`void`	`addOfflineDataMap(OfflineDataMap offlineDataMap)` Adds a new offline datamap to the data block
`void`	`addPamData(Tunit pamDataUnit)` Adds a new PamDataUnit to the PamDataBlock.
`void`	`autoSetDataBlockMixMode()`
`void`	`cancelDataOrder()`
`void`	`clearAll()` Clears all PamDataUnits from memory
`void`	`clearChannelIterators()`
`void`	`clearDeletedList()`
`int`	`createProcessAnnotations(PamDataBlock sourceData, ProcessAnnotator newAnnotations)` Copies all annotations over from the source DataBlock, then adds in the new ones from the new datablock.
`int`	`createProcessAnnotations(PamDataBlock sourceData, ProcessAnnotator newAnnotations, boolean notifyDownstream)` Copies all annotations over from the source DataBlock, then adds in the new ones from the new datablock.
`void`	`dumpBlockContents()`
`ProcessAnnotation`	`findAnnotation(ProcessAnnotation template)` Finds an annotation with the same type and name as the template annotation
`ProcessAnnotation`	`findAnnotation(java.lang.String type, java.lang.String name)` Finds an annotation with the given type and name
`Tunit`	`findByDatabaseIndex(int databaseIndex)` Find a dataunit based on it's database index.
`Tunit`	`findDataUnit(long timeMS, int channels)` Find a data unit.
`Tunit`	`findDataUnit(long timeMS, int channels, int absStartPos)` Find a unit that starts at a specific time.
`java.util.ArrayList<Tunit>`	`findUnitsinInterval(long startTime, long endTime)` Find a group of data units within a time window.
`BinaryDataSource`	`getBinaryDataSource()`
`boolean`	`getCanLog()`
`ChannelIterator<Tunit>`	`getChannelIterator(int channelMap, int whereFrom)` Get an iterator which can iterator through only data units with data from particular channels in a databock.
`int`	`getChannelIteratorCount()` Get the number of stored channel iterators for a datablock.
`int`	`getChannelMap()`
`Tunit`	`getClosestUnitMillis(long startTime)` Find the closest data unit to a given time.
`Tunit`	`getClosestUnitMillis(long startTime, int channelMap)` Find the closest data unit to a given time.
`long`	`getCurrentViewDataEnd()`
`long`	`getCurrentViewDataStart()`
`DataAnnotationType`	`getDataAnnotationType(int index)`
`double`	`getDataGain(int iChan)` Return the gain applied to any data created into this datablock.
`OfflineDataMap`	`getDatagrammedMap()` Get a data map which has a datagram
`DatagramProvider`	`getDatagramProvider()`
`java.lang.String`	`getDataName()`
`DataSelectorCreator`	`getDataSelectCreator()`
`DataSelector`	`getDataSelector(java.lang.String selectorName, boolean allowScores)` Convenience method to save programmer from having to call into the creator all the time.
`Tunit`	`getDataUnit(int ref, int refType)` Gets a reference to a data unit.
`Tunit`	`getFirstUnit()` Gets the first data unit stored
`Tunit`	`getFirstUnit(int channelMap)` Get the first unit for a specific channel map (any match of channels allowed).
`Tunit`	`getFirstUnitAfter(long timems)` Return the first DataUnit that is on or after the given time
`Tunit`	`getLastUnit()` Gets the last data unit stored
`Tunit`	`getLastUnit(int channelMap)` Get the last unit for a specific channel map (any match of channels allowed).
`java.util.ListIterator<Tunit>`	`getListIterator(int whereFrom)`
`java.util.ListIterator<Tunit>`	`getListIterator(long startTimeMillis, int channels, int match, int position)`
`java.util.ListIterator<Tunit>`	`getListIteratorFromEnd(long startTime, int channels, int match, int position)`
`java.util.ListIterator<Tunit>`	`getListIteratorFromStart(long startTime, int channels, int match, int position)`
`int`	`getLocalisationContents()`
`SQLLogging`	`getLogging()`
`java.lang.String`	`getLoggingName()`
`java.lang.String`	`getLongDataName()`
`int`	`getMixedDirection()`
`int`	`getNaturalLifetime()`
`int`	`getNaturalLifetimeMillis()`
`long`	`getNextDataStart(long timeMillis)` Get the next data start point.
`Tunit`	`getNextUnit(java.util.ListIterator<Tunit> listIterator, long startTime, int channelMap)` Finds the data unit after the given start time that has the same channel map.
`Tunit`	`getNextUnit(long startTime, int channelMap)` Simple function to find the data unit at or following the given start time that has a given channel bitmap
`int`	`getNumDataAnnotationTypes()`
`int`	`getNumOfflineDataMaps()`
`int`	`getNumRequiredBeforeLoadTime()` Get the number of pam data units that are required prior to the load times that get sent to loadViewerData.
`int`	`getOfflineData(PamObserver observer, PamObserver endUser, long startMillis, long endMillis, boolean allowRepeats, RequestCancellationObject cancellationObject)` Gets data for offline display, playback, etc.
`OfflineDataMap`	`getOfflineDataMap(int iMap)`
`OfflineDataMap`	`getOfflineDataMap(OfflineDataStore dataSource)`
`boolean`	`getOrderStatus()`
`PamProcess`	`getParentProcess()`
`Tunit`	`getPreceedingUnit(java.util.ListIterator<Tunit> listIterator, long startTime)` Finds the data unit before the given start time.
`Tunit`	`getPreceedingUnit(java.util.ListIterator<Tunit> listIterator, long startTime, int channelMap)` Finds the data unit before the given start time that has the same channel map.
`Tunit`	`getPreceedingUnit(long startTime)` Simple function to find the data unit at or before the given start time.
`Tunit`	`getPreceedingUnit(long startTime, int channelMap)` Simple function to find the data unit at or before the given start time that has a given channel bitmap
`long`	`getPrevDataEnd(long timeMillis)` Get the previous data end point.
`OfflineDataMap`	`getPrimaryDataMap()` New plan - always use the binary store if it has any data at all.
`java.util.Vector<ProcessAnnotation>`	`getProcessAnnotations()`
`int`	`getQuickId()` Quick integer datablock id which is based on the dataname
`PamRawDataBlock`	`getRawSourceDataBlock()`
`PamRawDataBlock`	`getRawSourceDataBlock2()` Tries to find the raw data block source of the current data block.
`Tunit`	`getRecycledUnit()` Gets a recycled data unit if one is available.
`int`	`getRecyclingStoreLength()`
`java.util.List<Tunit>`	`getRemovedItems()`
`ReverseChannelIterator<Tunit>`	`getReverseChannelIterator(int channelMap)` Get an iterator which can go backwards through a datablock, but only selects dataunits that have a channel map that overlaps with channelMap.
`float`	`getSampleRate()`
`SaveRequirements`	`getSaveRequirements(OfflineDataStore dataStore)` Work out some basic information about the elements that need saving from these data.
`boolean`	`getShouldBinary(PamDataUnit pamDataUnit)` Get flag to say whether data should be stored in the binary store
`boolean`	`getShouldLog(PamDataUnit pamDataUnit)` Should log the data unit to the database ?
`PamDataBlock`	`getSourceDataBlock()`
`PamProcess`	`getSourceProcess()`
`java.lang.Class`	`getUnitClass()`
`int`	`getUnitIndex(Tunit dataUnit)`
`int`	`getUnitsCount()`
`int`	`getUnitsCountFromTime(long countStart)`
`boolean`	`isCanClipGenerate()`
`boolean`	`isClearAtStart()` Flag to say that data should be cleared every time PAMGuard starts.
`boolean`	`isLinkGpsData()`
`boolean`	`isRecycling()`
`boolean`	`loadViewerData(long dataStart, long dataEnd, ViewLoadObserver loadObserver)` Instruction from the viewer scroll manager to load new data.
`void`	`masterClockUpdate(long milliSeconds, long clockSample)`
`void`	`noteNewSettings()` Tell all observers of this datablock that some control parameters have changed.
`void`	`notifyModelChanged(int changeType)` Receive notifications from the main PamController.
`void`	`orderOfflineData(PamObserver dataObserver, LoadObserver loadObserver, long startMillis, long endMillis, int interrupt)` Similar functionality to getOfflineData, but this will launch a separate worker thread to do the actual work getting the data.
`void`	`orderOfflineData(PamObserver dataObserver, LoadObserver loadObserver, long startMillis, long endMillis, int interrupt, boolean allowRepeats)` Similar functionality to getOfflineData, but this will launch a separate worker thread to do the actual work getting the data.
`void`	`remove()`
`boolean`	`remove(Tunit aDataUnit)`
`void`	`removeOfflineDataMap(OfflineDataStore dataSource)` remove a no longer needed offline data map.
`void`	`reset()` Reset a datablock.
`boolean`	`saveViewerData()` Saves data in this data block in offline viewer mode.
`void`	`setBinaryDataSource(BinaryDataSource binaryDataSource)`
`void`	`setCanClipGenerate(boolean canClipGenerate)`
`void`	`setChannelMap(int channelMap)`
`void`	`setClearAtStart(boolean clearAtStart)` Flag to say that data should be cleared every time PAMGuard starts.
`void`	`setDatagramProvider(DatagramProvider datagramProvider)`
`void`	`setDataName(java.lang.String dataName)`
`void`	`setLinkGpsData(boolean linkGpsData)`
`void`	`setLocalisationContents(int localisationContents)`
`void`	`SetLogging(SQLLogging logging)`
`void`	`setMixedDirection(int mixedDirection)`
`void`	`setNaturalLifetime(int naturalLifetime)` Set the natural lifetime of the data if there are no observers asking to keep it for longer
`void`	`setNaturalLifetimeMillis(int naturalLifetime)`
`void`	`setRecordingTrigger(RecorderTrigger recorderTrigger)`
`void`	`setRecycling(boolean recycling)`
`void`	`setRecyclingStoreLength(int recyclingStoreLength)`
`void`	`setSampleRate(float sampleRate, boolean notify)` Sets the sample rate for the block (e.g.
`void`	`setShouldBinary(boolean shouldBinary)` Set flag to say if data should be stored in the binary store.
`void`	`setShouldLog(boolean shouldLog)` Set if data should be logged to the database.
`boolean`	`shouldNotify()`
`void`	`sortData()` Sorts all the data units in the data block in order of time (unless a a data unit class choses to overwrite the compareTo function.
`java.lang.String`	`toString()`
`void`	`updatePamData(Tunit pamDataUnit, long updateTimeMillis)` update a dataunit.

Methods inherited from class PamguardMVC.PamObservable
canDraw, clearchanged, countObservers, createKeyItem, deleteObserver, deleteObservers, drawDataUnit, findThreadedObserver, getCPUPercent, getCPUPercent, getHoverText, getLongestObserver, getPamObservers, getRequiredHistory, hasOptionsDialog, notifyObservers, notifyObservers, setChanged, setOverlayDraw, showOptions, waitForThreadedObservers

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - REFERENCE_ABSOLUTE
```
public static final int REFERENCE_ABSOLUTE
```
    When getting a DataUnit from the Datablock, get the absolute data unit, i.e. the unit number as would be if none had ever been deleted
    
    See Also:
    Constant Field Values
  - REFERENCE_CURRENT
```
public static final int REFERENCE_CURRENT
```
    When getting a DataUnit from the Datablock, get the current data unit, i.e. the unit number in the current ArrayList
    
    See Also:
    Constant Field Values
  - MIX_DONOTHING
```
public static final int MIX_DONOTHING
```
    See Also:
    Constant Field Values
  - MIX_OUTOFDATABASE
```
public static final int MIX_OUTOFDATABASE
```
    See Also:
    Constant Field Values
  - MIX_INTODATABASE
```
public static final int MIX_INTODATABASE
```
    See Also:
    Constant Field Values
  - REQUEST_NO_DATA
```
public static final int REQUEST_NO_DATA
```
    No data available for offline loading.
    
    See Also:
    Constant Field Values
  - REQUEST_DATA_LOADED
```
public static final int REQUEST_DATA_LOADED
```
    Data loaded for requested time period.
    
    See Also:
    Constant Field Values
  - REQUEST_DATA_PARTIAL_LOAD
```
public static final int REQUEST_DATA_PARTIAL_LOAD
```
    Data partially loaded for requested time period
    
    See Also:
    Constant Field Values
  - REQUEST_SAME_REQUEST
```
public static final int REQUEST_SAME_REQUEST
```
    this is exactly the same data as requested last time.
    This flag will be used with one of the other three.
    
    See Also:
    Constant Field Values
  - REQUEST_INTERRUPTED
```
public static final int REQUEST_INTERRUPTED
```
    The request was interrupted (in multi thread load)
    
    See Also:
    Constant Field Values
  - REQUEST_EXCEPTION
```
public static final int REQUEST_EXCEPTION
```
    The request threw an exception of some sort.
    
    See Also:
    Constant Field Values
  - NOTIFY_NEW_DATA
```
public static final int NOTIFY_NEW_DATA
```
    See Also:
    Constant Field Values
  - NOTIFY_UPDATE_DATA
```
public static final int NOTIFY_UPDATE_DATA
```
    See Also:
    Constant Field Values
  - ITERATOR_END
```
public static final int ITERATOR_END
```
    See Also:
    Constant Field Values
  - MATCH_EXACT
```
public static final int MATCH_EXACT
```
    Only accept an iterator for a unit that matches the time exactly
    
    See Also:
    Constant Field Values
  - MATCH_BEFORE
```
public static final int MATCH_BEFORE
```
    If there is not exact time match, set the iterator so that the first element it returns will be the element before the requested time.
    
    See Also:
    Constant Field Values
  - MATCH_AFTER
```
public static final int MATCH_AFTER
```
    If there is not exact time match, set the iterator so that the first element it returns will be the element after the requested time.
    
    See Also:
    Constant Field Values
  - POSITION_BEFORE
```
public static final int POSITION_BEFORE
```
    Set the iterator so that a call to previous() will give the first wanted element
    
    See Also:
    Constant Field Values
  - POSITION_AFTER
```
public static final int POSITION_AFTER
```
    Set the iterator so that a call to next() will give the first wanted element
    
    See Also:
    Constant Field Values
  - OFFLINE_DATA_INTERRUPT
```
public static final int OFFLINE_DATA_INTERRUPT
```
    See Also:
    Constant Field Values
  - OFFLINE_DATA_WAIT
```
public static final int OFFLINE_DATA_WAIT
```
    See Also:
    Constant Field Values
  - OFFLINE_DATA_CANCEL
```
public static final int OFFLINE_DATA_CANCEL
```
    See Also:
    Constant Field Values
  - orderLock
```
public java.lang.Object orderLock
```
- Constructor Detail
  - PamDataBlock
```
public PamDataBlock(java.lang.Class unitClass,
            java.lang.String dataName,
            PamProcess parentProcess,
            int channelMap)
```
    PamDataBlock constructor.
    
    Parameters:
    unitClass - class of data unit to hold in this data block
    dataName - name of data block
    parentProcess - parent PamProcess
    channelMap - bitmap of channels which may be represented in data units in this data block.
- Method Detail
  - remove
```
public void remove()
```
  - getUnitsCount
```
public int getUnitsCount()
```
    Returns:
    The total number of PamDataUnits in the block
  - getUnitsCountFromTime
```
public int getUnitsCountFromTime(long countStart)
```
  - getRemovedItems
```
public java.util.List<Tunit> getRemovedItems()
```
    Returns:
    the removedItems list
  - getFirstUnitAfter
```
public Tunit getFirstUnitAfter(long timems)
```
    Return the first DataUnit that is on or after the given time
    
    Parameters:
    timems - Milliseconds - UTC in standard Java epoch
    
    Returns:
    a PamDataUnit or null if no data were found
  - findDataUnit
```
public Tunit findDataUnit(long timeMS,
                 int channels,
                 int absStartPos)
```
    Find a unit that starts at a specific time. searchStart may help to speed things up, however, now that a LinkedList is used in place of a vector, it's likely that this speed increase will be small.
    
    Parameters:
    timeMS - start time of data unit
    channels - channel bitmap of data unit, or 0 for any data unit
    absStartPos - start position for search, -1 if you want to start searching backwards from the end.
    
    Returns:
    data unit (or null if nothing found)
  - getReverseChannelIterator
```
public ReverseChannelIterator<Tunit> getReverseChannelIterator(int channelMap)
```
    Get an iterator which can go backwards through a datablock, but only selects dataunits that have a channel map that overlaps with channelMap. Note that only hasPrevious() and previous() work and that you cannot add, delete, or move forwards through this iterator.
    
    Parameters:
    channelMap - channel map for search
    
    Returns:
    a reverese iterator to go backwards through the data.
  - findDataUnit
```
public Tunit findDataUnit(long timeMS,
                 int channels)
```
    Find a data unit. By default, the search starts at the end of the list and works backwards on the assumption that we'll be more interested in more recent data.
    
    Parameters:
    timeMS - start time of PamDataUnit
    channels - channel bitmap of PamDataUnit
    
    Returns:
    found data unit, or null.
  - getUnitIndex
```
public int getUnitIndex(Tunit dataUnit)
```
  - findByDatabaseIndex
```
public Tunit findByDatabaseIndex(int databaseIndex)
```
    Find a dataunit based on it's database index. If there have been no updates, then database indexes should be in order and a fast find canbe used. If however, there have been updates, then things will not be in order so it's necessary to go through everything from start to end.
    
    Parameters:
    databaseIndex - Index to search for.
    
    Returns:
    found unit or null.
  - findUnitsinInterval
```
public java.util.ArrayList<Tunit> findUnitsinInterval(long startTime,
                                             long endTime)
```
    Find a group of data units within a time window.
    
    Parameters:
    startTime - time to search from in millis
    endTime - time to search to in millis
    
    Returns:
    An ArrayList of units between startTime and endTime. If no units are present in this time window an empty array will be returned.
  - clearAll
```
public void clearAll()
```
    Clears all PamDataUnits from memory
    In viewer mode, data are also re-saved.
  - reset
```
public void reset()
```
    Reset a datablock. This is called at PamStart from PamController It's been added in mostly to help with some issues surrounding sample numbering and timing when receiving Network data in which case the PamCalendar.getSessionStartTime may have been initialised when the sample count is already up in the zillions, in which case a lot of the timing functions won't work.
  - getCurrentViewDataStart
```
public long getCurrentViewDataStart()
```
    Returns:
    the start time of data currently loaded by the viewer.
  - getCurrentViewDataEnd
```
public long getCurrentViewDataEnd()
```
    Returns:
    the end time of data currently loaded by the viewer.
  - loadViewerData
```
public boolean loadViewerData(long dataStart,
                     long dataEnd,
                     ViewLoadObserver loadObserver)
```
    Instruction from the viewer scroll manager to load new data.
    
    Parameters:
    dataStart - data start time in millis
    dataEnd - data end time in millis.
  - saveViewerData
```
public boolean saveViewerData()
```
    Saves data in this data block in offline viewer mode.
    
    Returns:
    true if data found and saved.
  - getNumRequiredBeforeLoadTime
```
public int getNumRequiredBeforeLoadTime()
```
    Get the number of pam data units that are required prior to the load times that get sent to loadViewerData. This can be used for things like hydrophone data where it may be necessary to load up a few earlier points to complete a trackline, etc.
    
    Returns:
    number of units required.
  - addPamData
```
public void addPamData(Tunit pamDataUnit)
```
    Adds a new PamDataUnit to the PamDataBlock. When the data unit is added, PamObservers that have subscribed to the block will be notified.
    
    Parameters:
    pamDataUnit - Reference to a PamDataUnit
  - updatePamData
```
public void updatePamData(Tunit pamDataUnit,
                 long updateTimeMillis)
```
    update a dataunit. Does little except flag that the data unit is updated (so it will get saved), and sends notifications to other modules.
    
    Parameters:
    pamDataUnit -
    updateTimeMillis -
  - shouldNotify
```
public boolean shouldNotify()
```
  - remove
```
public boolean remove(Tunit aDataUnit)
```
  - getRecycledUnit
```
public Tunit getRecycledUnit()
```
    Gets a recycled data unit if one is available.
    
    Returns:
    recycled unit, or null
  - getSourceDataBlock
```
public PamDataBlock getSourceDataBlock()
```
  - getDataUnit
```
public Tunit getDataUnit(int ref,
                int refType)
```
    Gets a reference to a data unit.
    
    Parameters:
    ref - number of the data unit
    refType - REFERENCE_ABSOLUTE or REFERENCE_CURRENT
    
    Returns:
    DataUnit \n If refType is REFERENCE_ABSOLUTE then the data unit with the absolute position ref is returned (if it has not yet been deleted). This might be used to re-access a specific unit or to access the unit coming directly before or after a previously accessed unit. \n If refType is REFERENCE_CURRENT then the data unit at that position in the current ArrayList is returned.
  - getLastUnit
```
public Tunit getLastUnit()
```
    Gets the last data unit stored
    
    Returns:
    data unit or null
  - getLastUnit
```
public Tunit getLastUnit(int channelMap)
```
    Get the last unit for a specific channel map (any match of channels allowed).
    
    Parameters:
    channelMap - channel map
    
    Returns:
    last data unit with at least one channel matching, or null.
  - getFirstUnit
```
public Tunit getFirstUnit()
```
    Gets the first data unit stored
    
    Returns:
    data unit or null
  - getFirstUnit
```
public Tunit getFirstUnit(int channelMap)
```
    Get the first unit for a specific channel map (any match of channels allowed).
    
    Parameters:
    channelMap - channel map
    
    Returns:
    last data unit with at least one channel matching, or null.
  - getPreceedingUnit
```
public Tunit getPreceedingUnit(java.util.ListIterator<Tunit> listIterator,
                      long startTime)
```
    Finds the data unit before the given start time.
    This implementation is passed an iterator which has already been initialised to be at the END of the list. In this way, the calling function has access to the iterator and can access nearby elements.
    
    Parameters:
    listIterator - pre initialised ListIterator
    startTime - search time in milliseconds
    
    Returns:
    data unit at or following the given time.
    See Also:
    ListIterator
  - getPreceedingUnit
```
public Tunit getPreceedingUnit(java.util.ListIterator<Tunit> listIterator,
                      long startTime,
                      int channelMap)
```
    Finds the data unit before the given start time that has the same channel map.
    This implementation is passed an iterator which has already been initialised to be at the END of the list. In this way, the calling function has access to the iterator and can access nearby elements.
    
    Parameters:
    listIterator - pre initialised ListIterator
    startTime - search time in milliseconds
    channelMap - Channel bitmap
    
    Returns:
    data unit at or following the given time.
    See Also:
    ListIterator
  - getPreceedingUnit
```
public Tunit getPreceedingUnit(long startTime)
```
    Simple function to find the data unit at or before the given start time.
    
    Parameters:
    startTime - search time in milliseconds
    
    Returns:
    data unit at or following the given time.
  - getPreceedingUnit
```
public Tunit getPreceedingUnit(long startTime,
                      int channelMap)
```
    Simple function to find the data unit at or before the given start time that has a given channel bitmap
    
    Parameters:
    startTime - search time in milliseconds
    channelMap - Channel bitmap
    
    Returns:
    data unit at or following the given time.
  - getNextUnit
```
public Tunit getNextUnit(java.util.ListIterator<Tunit> listIterator,
                long startTime,
                int channelMap)
```
    Finds the data unit after the given start time that has the same channel map.
    This implementation is passed an iterator which has already been initialised to be at the END of the list. In this way, the calling function has access to the iterator and can access nearby elements.
    
    Parameters:
    listIterator - pre initialised ListIterator
    startTime - search time in milliseconds
    channelMap - Channel bitmap
    
    Returns:
    data unit at or following the given time.
    See Also:
    ListIterator
  - getNextUnit
```
public Tunit getNextUnit(long startTime,
                int channelMap)
```
    Simple function to find the data unit at or following the given start time that has a given channel bitmap
    
    Parameters:
    startTime - search time in milliseconds
    channelMap - Channel bitmap
    
    Returns:
    data unit at or following the given time.
  - getClosestUnitMillis
```
public Tunit getClosestUnitMillis(long startTime)
```
    Find the closest data unit to a given time.
    
    Parameters:
    startTime - Start time of data unit (milliseconds)
    
    Returns:
    closest data unit
  - getClosestUnitMillis
```
public Tunit getClosestUnitMillis(long startTime,
                         int channelMap)
```
    Find the closest data unit to a given time.
    
    Parameters:
    startTime - Start time of data unit (milliseconds)
    channelMap - Channel map - must be some overlap, not an exact match.
    
    Returns:
    closest data unit
  - getSampleRate
```
public float getSampleRate()
```
    Returns:
    The sample rate of the data contained in the block
  - getDataName
```
public java.lang.String getDataName()
```
    Returns:
    Name of the data in the block.
  - getLongDataName
```
public java.lang.String getLongDataName()
```
  - setSampleRate
```
public void setSampleRate(float sampleRate,
                 boolean notify)
```
    Sets the sample rate for the block (e.g. call this after opening a sound file and reading the sample rate from the file header or after altering sound card settings). All observers of this block (PamProcesses and some views) are notified, they in turn should tell their own output PamDataBlocks about the change.
    
    Parameters:
    sampleRate - The new sample rate in Hz.
    notify - set true if Observers should be notified
  - masterClockUpdate
```
public void masterClockUpdate(long milliSeconds,
                     long clockSample)
```
  - noteNewSettings
```
public void noteNewSettings()
```
    Tell all observers of this datablock that some control parameters have changed. Modified July 09 to make sure it doesn't loop through itself when using threaded observers.
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - getNaturalLifetime
```
public int getNaturalLifetime()
```
    Returns:
    Finds the original data block, i.e. the one that has a PamProcess with no source data block.
  - setNaturalLifetimeMillis
```
public void setNaturalLifetimeMillis(int naturalLifetime)
```
  - getNaturalLifetimeMillis
```
public int getNaturalLifetimeMillis()
```
  - setNaturalLifetime
```
public void setNaturalLifetime(int naturalLifetime)
```
    Set the natural lifetime of the data if there are no observers asking to keep it for longer
    
    Parameters:
    naturalLifetime - in seconds (NOT milliseconds)
  - isLinkGpsData
```
public boolean isLinkGpsData()
```
  - setLinkGpsData
```
public void setLinkGpsData(boolean linkGpsData)
```
  - getChannelMap
```
public int getChannelMap()
```
  - getDataGain
```
public double getDataGain(int iChan)
```
    Return the gain applied to any data created into this datablock.
    Example 1: The amplifier module will just return it's gain
    Example 2: The FFT module will return the loss due to windowing the data.
    To convert to dB use 20*log10(Math.abs(getDataGain()));
    
    Parameters:
    iChan - channel number
    
    Returns:
    gain as a factor (to allow for negative gains)
  - setChannelMap
```
public void setChannelMap(int channelMap)
```
  - setDataName
```
public void setDataName(java.lang.String dataName)
```
    Parameters:
    dataName - The dataName to set.
  - getLoggingName
```
public java.lang.String getLoggingName()
```
  - getParentProcess
```
public PamProcess getParentProcess()
```
    Returns:
    Returns the parentProcess.
  - getSourceProcess
```
public PamProcess getSourceProcess()
```
    Returns:
    Returns the sourceProcess.
  - getRawSourceDataBlock
```
public PamRawDataBlock getRawSourceDataBlock()
```
  - getRawSourceDataBlock2
```
public PamRawDataBlock getRawSourceDataBlock2()
```
    Tries to find the raw data block source of the current data block. It does this by bouncing back and forth from ParentProcess to ParentDataBlock and back again, until either the ParentProcess or the ParentDataBlock is null.
    Note that this does not search specifically for a PamRawDataBlock; it searches for the first data block in the chain, and then tests to see whether that data block is of class PamRawDataBlock.
    
    Returns:
    the PamRawDataBlock that serves as the source data, or null if no data block is found
  - addObserver
```
public void addObserver(PamObserver o)
```
    Description copied from class: PamObservable
    
    Adds a PamObserver, which will then receive notifications when data is added. This is for single thread ops only
    
    Overrides:
    
    addObserver in class PamObservable
    
    Parameters:
    o - Reference to the observer
  - addObserver
```
public void addObserver(PamObserver o,
               boolean reThread)
```
    Overrides:
    
    addObserver in class PamObservable
  - getUnitClass
```
public java.lang.Class getUnitClass()
```
    Returns:
    Class type for the sotred data units in this data block.
  - autoSetDataBlockMixMode
```
public void autoSetDataBlockMixMode()
```
  - getMixedDirection
```
public int getMixedDirection()
```
  - setMixedDirection
```
public void setMixedDirection(int mixedDirection)
```
  - getLocalisationContents
```
public int getLocalisationContents()
```
  - setLocalisationContents
```
public void setLocalisationContents(int localisationContents)
```
  - addLocalisationContents
```
public void addLocalisationContents(int localisationContents)
```
  - getListIterator
```
public java.util.ListIterator<Tunit> getListIterator(int whereFrom)
```
  - getListIterator
```
public java.util.ListIterator<Tunit> getListIterator(long startTimeMillis,
                                            int channels,
                                            int match,
                                            int position)
```
  - getListIteratorFromStart
```
public java.util.ListIterator<Tunit> getListIteratorFromStart(long startTime,
                                                     int channels,
                                                     int match,
                                                     int position)
```
  - dumpBlockContents
```
public void dumpBlockContents()
```
  - getListIteratorFromEnd
```
public java.util.ListIterator<Tunit> getListIteratorFromEnd(long startTime,
                                                   int channels,
                                                   int match,
                                                   int position)
```
  - getProcessAnnotations
```
public java.util.Vector<ProcessAnnotation> getProcessAnnotations()
```
  - createProcessAnnotations
```
public int createProcessAnnotations(PamDataBlock sourceData,
                           ProcessAnnotator newAnnotations)
```
    Copies all annotations over from the source DataBlock, then adds in the new ones from the new datablock.
    
    Parameters:
    sourceData - source Datablock
    newAnnotations - source of new annotations
    
    Returns:
    total number of annotations
  - createProcessAnnotations
```
public int createProcessAnnotations(PamDataBlock sourceData,
                           ProcessAnnotator newAnnotations,
                           boolean notifyDownstream)
```
    Copies all annotations over from the source DataBlock, then adds in the new ones from the new datablock.
    
    Parameters:
    sourceData - source Datablock
    newAnnotations - source of new annotations
    notifydownstream - notify downstream modules.
    
    Returns:
    total number of annotations
  - findAnnotation
```
public ProcessAnnotation findAnnotation(java.lang.String type,
                               java.lang.String name)
```
    Finds an annotation with the given type and name
    
    Parameters:
    type - annotation type
    name - annotation name
    
    Returns:
    annotation object
  - findAnnotation
```
public ProcessAnnotation findAnnotation(ProcessAnnotation template)
```
    Finds an annotation with the same type and name as the template annotation
    
    Parameters:
    template - template annotation
    
    Returns:
    annotation object
  - setRecycling
```
public void setRecycling(boolean recycling)
```
    Parameters:
    recycling - the recycling to set
  - isRecycling
```
public boolean isRecycling()
```
    Returns:
    the recycling
  - setRecyclingStoreLength
```
public void setRecyclingStoreLength(int recyclingStoreLength)
```
    Parameters:
    recyclingStoreLength - the recyclingStoreLength to set
  - getRecyclingStoreLength
```
public int getRecyclingStoreLength()
```
    Returns:
    the recyclingStoreLength
  - notifyModelChanged
```
public void notifyModelChanged(int changeType)
```
    Receive notifications from the main PamController.
    
    Parameters:
    changeType -
  - setBinaryDataSource
```
public void setBinaryDataSource(BinaryDataSource binaryDataSource)
```
    Parameters:
    siterBinaryDataSource - the siterBinaryDataSource to set
  - getBinaryDataSource
```
public BinaryDataSource getBinaryDataSource()
```
    Returns:
    the siterBinaryDataSource
  - SetLogging
```
public void SetLogging(SQLLogging logging)
```
  - getLogging
```
public SQLLogging getLogging()
```
  - getCanLog
```
public final boolean getCanLog()
```
  - getShouldLog
```
public boolean getShouldLog(PamDataUnit pamDataUnit)
```
    Should log the data unit to the database ?
    
    Parameters:
    pamDataUnit - dataunit to consider
    
    Returns:
    true if data should be logged.
  - setShouldLog
```
public final void setShouldLog(boolean shouldLog)
```
    Set if data should be logged to the database.
    
    Parameters:
    shouldLog - flag to log data.
  - getShouldBinary
```
public boolean getShouldBinary(PamDataUnit pamDataUnit)
```
    Get flag to say whether data should be stored in the binary store
    
    Parameters:
    pamDataUnit - data unit
    
    Returns:
    true if the data unit shoule be saved.
  - setShouldBinary
```
public void setShouldBinary(boolean shouldBinary)
```
    Set flag to say if data should be stored in the binary store.
    
    Parameters:
    shouldBinary - flag to say data shoule be stored.
  - addOfflineDataMap
```
public void addOfflineDataMap(OfflineDataMap offlineDataMap)
```
    Adds a new offline datamap to the data block
    Note that there may be several maps from different types of storage (although only one should have anything in it in a sensible world).
    It's also possible that these will be recreated during a run, and we don't want two of the same type in the same datablock, so check that there isn't already one and remove it
    
    Parameters:
    offlineDataMap -
  - getNumOfflineDataMaps
```
public int getNumOfflineDataMaps()
```
    Returns:
    the number of different offline data maps
  - getOfflineDataMap
```
public OfflineDataMap getOfflineDataMap(int iMap)
```
    Parameters:
    iMap - index of map (see getNumOfflineDataMaps)
    
    Returns:
    an OfflineDataMap from that index in the list.
  - getOfflineDataMap
```
public OfflineDataMap getOfflineDataMap(OfflineDataStore dataSource)
```
    Parameters:
    dataSource - an offline data source (e.g. binaray storage, database storage, etc.
    
    Returns:
    the offline data map for a specific OfflineDataSource or null
  - getPrimaryDataMap
```
public OfflineDataMap getPrimaryDataMap()
```
    New plan - always use the binary store if it has any data at all. If the binary store doesn't exist or is empty, only then use the database.
    
    Returns:
    a data map
  - getDatagrammedMap
```
public OfflineDataMap getDatagrammedMap()
```
    Get a data map which has a datagram
    
    Returns:
  - removeOfflineDataMap
```
public void removeOfflineDataMap(OfflineDataStore dataSource)
```
    remove a no longer needed offline data map.
    
    Parameters:
    dataSource - data source (e.g. binary, database, raw data, etc.
  - getSaveRequirements
```
public SaveRequirements getSaveRequirements(OfflineDataStore dataStore)
```
    Work out some basic information about the elements that need saving from these data.
    
    Parameters:
    dataStore - data source that want's to save the data.
    
    Returns:
    an object of information
  - orderOfflineData
```
public void orderOfflineData(PamObserver dataObserver,
                    LoadObserver loadObserver,
                    long startMillis,
                    long endMillis,
                    int interrupt)
```
    Similar functionality to getOfflineData, but this will launch a separate worker thread to do the actual work getting the data. The worker thread will call getOfflineData.
    getOfflineData will probably (if not overridden) be sending data to the update member function of the observer, but from the worker thread. Once it's complete, it will send a message to say that data are loaded.
    It's possible that the user will do something which causes this to be called again before the previous thread completed execution, in which case there are three options:
    OFFLINE_DATA_INTERRUPT - previous thread will be terminated
    OFFLINE_DATA_WAIT - wait for previous thread to terminate, then start this load
    OFFLINE_DATA_CANCEL - give up and return
    
    Parameters:
    dataObserver - observer of the loaded data
    loadObserver - observer to get status information on the load.
    startMillis - data start time in imilliseconds
    endMillis - data end time in milliseconds.
    interrupt - interrupt options.
  - orderOfflineData
```
public void orderOfflineData(PamObserver dataObserver,
                    LoadObserver loadObserver,
                    long startMillis,
                    long endMillis,
                    int interrupt,
                    boolean allowRepeats)
```
    Similar functionality to getOfflineData, but this will launch a separate worker thread to do the actual work getting the data. The worker thread will call getOfflineData.
    getOfflineData will probably (if not overridden) be sending data to the update member function of the observer, but from the worker thread. Once it's complete, it will send a message to say that data are loaded.
    It's possible that the user will do something which causes this to be called again before the previous thread completed execution, in which case there are three options:
    OFFLINE_DATA_INTERRUPT - previous thread will be terminated
    OFFLINE_DATA_WAIT - wait for previous thread to terminate, then start this load
    OFFLINE_DATA_CANCEL - give up and return
    
    Parameters:
    dataObserver - observer of the loaded data
    loadObserver - observer to get status information on the load.
    startMillis - data start time in imilliseconds
    endMillis - data end time in milliseconds.
    interrupt - interrupt options.
    allowRepeats - allow repeated loads of exactly the same data.
  - cancelDataOrder
```
public void cancelDataOrder()
```
  - getOrderStatus
```
public boolean getOrderStatus()
```
    Returns:
    true if an order for data is currently still being processed.
  - getOfflineData
```
public int getOfflineData(PamObserver observer,
                 PamObserver endUser,
                 long startMillis,
                 long endMillis,
                 boolean allowRepeats,
                 RequestCancellationObject cancellationObject)
```
    Gets data for offline display, playback, etc.
    This is used to get data from some upstream process which is quite different to the function loadViewerData(...) which loads data directly associated with this data block.
    For example, this might be called in the FFT data block by the spectrogram which wants some data to display. The FFT data block does not have this data, so it passes the request up to it's process which will in turn pass the request on until it reaches a module which is capable of loading data into data units and sending them back down the line.
    
    Parameters:
    observer - data observer which will receive the data
    startMillis - start time in milliseconds
    endMillis - end time in milliseconds
    allowRepeats - allow the same data to be loaded a second time.
    cancellationObject -
    
    Returns:
    answer: .
  - clearDeletedList
```
public void clearDeletedList()
```
  - getNextDataStart
```
public long getNextDataStart(long timeMillis)
```
    Get the next data start point. i.e. the time of the start of a map point which is > timeMillis
    
    Parameters:
    timeMillis - current time in milliseconds
    
    Returns:
    start time of the next data start.
  - getPrevDataEnd
```
public long getPrevDataEnd(long timeMillis)
```
    Get the previous data end point. i.e. the time of the end of a map point which is < timeMillis
    
    Parameters:
    timeMillis - current time in milliseconds
    
    Returns:
    start time of the next data start.
  - setDatagramProvider
```
public void setDatagramProvider(DatagramProvider datagramProvider)
```
  - getDatagramProvider
```
public DatagramProvider getDatagramProvider()
```
  - isCanClipGenerate
```
public boolean isCanClipGenerate()
```
    Returns:
    the canClipGenerate
  - setCanClipGenerate
```
public void setCanClipGenerate(boolean canClipGenerate)
```
    Parameters:
    canClipGenerate - the canClipGenerate to set
  - getQuickId
```
public int getQuickId()
```
    Quick integer datablock id which is based on the dataname
    
    Returns:
  - sortData
```
public void sortData()
```
    Sorts all the data units in the data block in order of time (unless a a data unit class choses to overwrite the compareTo function.
  - setRecordingTrigger
```
public void setRecordingTrigger(RecorderTrigger recorderTrigger)
```
  - getChannelIterator
```
public ChannelIterator<Tunit> getChannelIterator(int channelMap,
                                        int whereFrom)
```
    Get an iterator which can iterator through only data units with data from particular channels in a databock.
    In viewer mode, channel iterators are saved for reuse but will be deleted / cleared if data are removed or added to the datablock to avoid concurrency exceptions.
    
    Parameters:
    channelMap - channel map
    whereFrom - 0, start at start,
    
    Returns:
    a channel iterator
  - clearChannelIterators
```
public void clearChannelIterators()
```
  - getChannelIteratorCount
```
public int getChannelIteratorCount()
```
    Get the number of stored channel iterators for a datablock.
    
    Returns:
    the number of channel iterators currently associated with this data block.
  - addDataAnnotationType
```
public void addDataAnnotationType(DataAnnotationType dataAnnotationType)
```
    Add a data annotation type to a datablock.
    
    Parameters:
    dataAnnotationType -
  - getNumDataAnnotationTypes
```
public int getNumDataAnnotationTypes()
```
  - getDataAnnotationType
```
public DataAnnotationType getDataAnnotationType(int index)
```
  - isClearAtStart
```
public boolean isClearAtStart()
```
    Flag to say that data should be cleared every time PAMGuard starts. Is true by default, but some modules may want to set this false for some streams.
    
    Returns:
    the clearAtStart
  - setClearAtStart
```
public void setClearAtStart(boolean clearAtStart)
```
    Flag to say that data should be cleared every time PAMGuard starts. Is true by default, but some modules may want to set this false for some streams.
    
    Parameters:
    clearAtStart - the clearAtStart to set
  - getDataSelectCreator
```
public DataSelectorCreator getDataSelectCreator()
```
    Returns:
    an object that can create data selectors to sub select data from within this type of data block.
  - getDataSelector
```
public DataSelector getDataSelector(java.lang.String selectorName,
                           boolean allowScores)
```
    Convenience method to save programmer from having to call into the creator all the time.
    
    Parameters:
    selectorName -
    allowScores -
    
    Returns:
    null or a DataSelector

Class PamDataBlock<Tunit extends PamDataUnit>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class PamguardMVC.PamObservable

Methods inherited from class java.lang.Object

Field Detail

REFERENCE_ABSOLUTE

REFERENCE_CURRENT

MIX_DONOTHING

MIX_OUTOFDATABASE

MIX_INTODATABASE

REQUEST_NO_DATA

REQUEST_DATA_LOADED

REQUEST_DATA_PARTIAL_LOAD

REQUEST_SAME_REQUEST

REQUEST_INTERRUPTED

REQUEST_EXCEPTION

NOTIFY_NEW_DATA

NOTIFY_UPDATE_DATA

ITERATOR_END

MATCH_EXACT

MATCH_BEFORE

MATCH_AFTER

POSITION_BEFORE

POSITION_AFTER

OFFLINE_DATA_INTERRUPT

OFFLINE_DATA_WAIT

OFFLINE_DATA_CANCEL

orderLock

Constructor Detail

PamDataBlock

Method Detail

remove

getUnitsCount

getUnitsCountFromTime

getRemovedItems

getFirstUnitAfter

findDataUnit

getReverseChannelIterator

findDataUnit

getUnitIndex

findByDatabaseIndex

findUnitsinInterval

clearAll

reset

getCurrentViewDataStart

getCurrentViewDataEnd

loadViewerData

saveViewerData

getNumRequiredBeforeLoadTime

addPamData

updatePamData

shouldNotify

remove

getRecycledUnit

getSourceDataBlock

getDataUnit

getLastUnit

getLastUnit

getFirstUnit

getFirstUnit

getPreceedingUnit

getPreceedingUnit

getPreceedingUnit

getPreceedingUnit

getNextUnit

getNextUnit

getClosestUnitMillis

getClosestUnitMillis

getSampleRate

getDataName

getLongDataName

setSampleRate

masterClockUpdate

noteNewSettings

toString

getNaturalLifetime

setNaturalLifetimeMillis

getNaturalLifetimeMillis