GitHub/sdrtrunk
1
0
Fork 0
mirror of https://github.com/DSheirer/sdrtrunk.git synced 2026-11-13 09:07:27 -05:00
Code Issues Packages Projects Releases 2 Wiki Activity

Resolves issue with Null Pointer exception in alias list

Browse Source
This commit is contained in:
Denny
2017-02-20 20:19:47 -05:00
parent 17c7466c6b
commit 234e313b7a
1 changed files with 265 additions and 262 deletions
Download Patch File Download Diff File Expand all files Collapse all files

465
src/alias/AliasModel.java
View File

@@ -17,6 +17,12 @@
******************************************************************************/ ******************************************************************************/
package alias; package alias;
import alias.AliasEvent.Event;
import alias.id.broadcast.BroadcastChannel;
import sample.Broadcaster;
import sample.Listener;
import javax.swing.table.AbstractTableModel;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collections; import java.util.Collections;
import java.util.HashMap; import java.util.HashMap;
@@ -24,195 +30,192 @@ import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.concurrent.CopyOnWriteArrayList; import java.util.concurrent.CopyOnWriteArrayList;
import javax.swing.table.AbstractTableModel;
import alias.id.broadcast.BroadcastChannel;
import sample.Broadcaster;
import sample.Listener;
import alias.AliasEvent.Event;
/** /**
* Alias Model * Alias Model
*/ */
public class AliasModel extends AbstractTableModel public class AliasModel extends AbstractTableModel
{ {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
public static final int COLUMN_LIST = 0; public static final int COLUMN_LIST = 0;
public static final int COLUMN_GROUP = 1; public static final int COLUMN_GROUP = 1;
public static final int COLUMN_NAME = 2; public static final int COLUMN_NAME = 2;
public static final int COLUMN_ICON = 3; public static final int COLUMN_ICON = 3;
public static final int COLUMN_COLOR = 4; public static final int COLUMN_COLOR = 4;
private List<Alias> mAliases = new CopyOnWriteArrayList<>(); private List<Alias> mAliases = new CopyOnWriteArrayList<>();
private Broadcaster<AliasEvent> mAliasEventBroadcaster = new Broadcaster<>(); private Broadcaster<AliasEvent> mAliasEventBroadcaster = new Broadcaster<>();
private Map<String,AliasList> mAliasListMap = new HashMap<>(); private Map<String,AliasList> mAliasListMap = new HashMap<>();
public AliasModel() public AliasModel()
{ {
} }
/** /**
* Unmodifiable list of all aliases currently in the model * Unmodifiable list of all aliases currently in the model
*/ */
public List<Alias> getAliases() public List<Alias> getAliases()
{ {
return Collections.unmodifiableList( mAliases ); return Collections.unmodifiableList(mAliases);
} }
public Alias getAliasAtIndex( int row ) public Alias getAliasAtIndex(int row)
{ {
if( mAliases.size() >= row ) if(mAliases.size() >= row)
{ {
return mAliases.get( row ); return mAliases.get(row);
} }
return null; return null;
} }
public AliasList getAliasList( String name ) public AliasList getAliasList(String name)
{ {
if( mAliasListMap.containsKey( name ) ) if(name != null && mAliasListMap.containsKey(name))
{ {
return mAliasListMap.get( name ); return mAliasListMap.get(name);
} }
AliasList aliasList = new AliasList( name ); AliasList aliasList = new AliasList(name);
for( Alias alias: mAliases ) if(name != null)
{ {
if( alias.getList().equalsIgnoreCase( name ) ) for(Alias alias : mAliases)
{ {
aliasList.addAlias( alias ); if(alias.getList().equalsIgnoreCase(name))
} {
} aliasList.addAlias(alias);
}
}
mAliasListMap.put( name, aliasList ); mAliasListMap.put(name, aliasList);
//Register the new alias list to receive updates from this model //Register the new alias list to receive updates from this model
addListener( aliasList ); addListener(aliasList);
}
return aliasList; return aliasList;
} }
/** /**
* Returns a list of unique alias list names from across the alias set * Returns a list of unique alias list names from across the alias set
*/ */
public List<String> getListNames() public List<String> getListNames()
{ {
List<String> listNames = new ArrayList<>(); List<String> listNames = new ArrayList<>();
for( Alias alias: mAliases ) for(Alias alias : mAliases)
{ {
if( alias.hasList() && !listNames.contains( alias.getList() ) ) if(alias.hasList() && !listNames.contains(alias.getList()))
{ {
listNames.add( alias.getList() ); listNames.add(alias.getList());
} }
} }
Collections.sort( listNames ); Collections.sort(listNames);
return listNames; return listNames;
} }
/** /**
* Returns a list of alias group names for all aliases * Returns a list of alias group names for all aliases
*/ */
public List<String> getGroupNames() public List<String> getGroupNames()
{ {
List<String> groupNames = new ArrayList<>(); List<String> groupNames = new ArrayList<>();
for( Alias alias: mAliases ) for(Alias alias : mAliases)
{ {
if( alias.hasGroup() && !groupNames.contains( alias.getGroup() ) ) if(alias.hasGroup() && !groupNames.contains(alias.getGroup()))
{ {
groupNames.add( alias.getGroup() ); groupNames.add(alias.getGroup());
} }
} }
Collections.sort( groupNames ); Collections.sort(groupNames);
return groupNames; return groupNames;
} }
/** /**
* Returns a list of alias group names for all aliases that have a matching * Returns a list of alias group names for all aliases that have a matching
* list name value * list name value
*/ */
public List<String> getGroupNames( String listName ) public List<String> getGroupNames(String listName)
{ {
List<String> groupNames = new ArrayList<>(); List<String> groupNames = new ArrayList<>();
if( listName != null ) if(listName != null)
{ {
for( Alias alias: mAliases ) for(Alias alias : mAliases)
{ {
if( alias.hasList() && if(alias.hasList() &&
alias.hasGroup() && alias.hasGroup() &&
listName.equals( alias.getList() ) && listName.equals(alias.getList()) &&
!groupNames.contains( alias.getGroup() ) ) !groupNames.contains(alias.getGroup()))
{ {
groupNames.add( alias.getGroup() ); groupNames.add(alias.getGroup());
} }
} }
} }
Collections.sort( groupNames ); Collections.sort(groupNames);
return groupNames; return groupNames;
} }
/** /**
* Bulk loading of aliases * Bulk loading of aliases
*/ */
public void addAliases( List<Alias> aliases ) public void addAliases(List<Alias> aliases)
{ {
for( Alias alias: aliases ) for(Alias alias : aliases)
{ {
addAlias( alias ); addAlias(alias);
} }
} }
/** /**
* Adds the alias to the model * Adds the alias to the model
*/ */
public int addAlias( Alias alias ) public int addAlias(Alias alias)
{ {
if( alias != null ) if(alias != null)
{ {
mAliases.add( alias ); mAliases.add(alias);
int index = mAliases.size() - 1; int index = mAliases.size() - 1;
fireTableRowsInserted( index, index ); fireTableRowsInserted(index, index);
broadcast( new AliasEvent( alias, Event.ADD ) ); broadcast(new AliasEvent(alias, Event.ADD));
return index; return index;
} }
return -1; return -1;
} }
/** /**
* Removes the channel from the model and broadcasts a channel remove event * Removes the channel from the model and broadcasts a channel remove event
*/ */
public void removeAlias( Alias alias ) public void removeAlias(Alias alias)
{ {
if( alias != null ) if(alias != null)
{ {
int index = mAliases.indexOf( alias ); int index = mAliases.indexOf(alias);
mAliases.remove( alias ); mAliases.remove(alias);
fireTableRowsDeleted( index, index ); fireTableRowsDeleted(index, index);
broadcast( new AliasEvent( alias, Event.DELETE ) ); broadcast(new AliasEvent(alias, Event.DELETE));
} }
} }
/** /**
* Renames any broadcast channels that have the previous name. * Renames any broadcast channels that have the previous name.
*
* @param previousName to rename * @param previousName to rename
* @param newName to assign to the broadcast channel * @param newName to assign to the broadcast channel
*/ */
@@ -223,11 +226,11 @@ public class AliasModel extends AbstractTableModel
return; return;
} }
for(Alias alias: mAliases) for(Alias alias : mAliases)
{ {
if(alias.hasBroadcastChannel(previousName)) if(alias.hasBroadcastChannel(previousName))
{ {
for(BroadcastChannel broadcastChannel: alias.getBroadcastChannels()) for(BroadcastChannel broadcastChannel : alias.getBroadcastChannels())
{ {
if(broadcastChannel.getChannelName().contentEquals(previousName)) if(broadcastChannel.getChannelName().contentEquals(previousName))
{ {
@@ -238,85 +241,85 @@ public class AliasModel extends AbstractTableModel
} }
} }
@Override @Override
public int getRowCount() public int getRowCount()
{ {
return mAliases.size(); return mAliases.size();
} }
@Override @Override
public int getColumnCount() public int getColumnCount()
{ {
return 5; return 5;
} }
@Override @Override
public String getColumnName( int columnIndex ) public String getColumnName(int columnIndex)
{ {
switch( columnIndex ) switch(columnIndex)
{ {
case COLUMN_LIST: case COLUMN_LIST:
return "List"; return "List";
case COLUMN_GROUP: case COLUMN_GROUP:
return "Group"; return "Group";
case COLUMN_NAME: case COLUMN_NAME:
return "Name"; return "Name";
case COLUMN_ICON: case COLUMN_ICON:
return "Icon"; return "Icon";
case COLUMN_COLOR: case COLUMN_COLOR:
return "Color"; return "Color";
} }
return null; return null;
} }
@Override @Override
public Class<?> getColumnClass( int columnIndex ) public Class<?> getColumnClass(int columnIndex)
{ {
if( columnIndex == COLUMN_COLOR ) if(columnIndex == COLUMN_COLOR)
{ {
return Integer.class; return Integer.class;
} }
return String.class; return String.class;
} }
@Override @Override
public boolean isCellEditable( int rowIndex, int columnIndex ) public boolean isCellEditable(int rowIndex, int columnIndex)
{ {
return false; return false;
} }
@Override @Override
public Object getValueAt( int rowIndex, int columnIndex ) public Object getValueAt(int rowIndex, int columnIndex)
{ {
Alias alias = mAliases.get( rowIndex ); Alias alias = mAliases.get(rowIndex);
switch( columnIndex ) switch(columnIndex)
{ {
case COLUMN_LIST: case COLUMN_LIST:
return alias.getList(); return alias.getList();
case COLUMN_GROUP: case COLUMN_GROUP:
return alias.getGroup(); return alias.getGroup();
case COLUMN_NAME: case COLUMN_NAME:
return alias.getName(); return alias.getName();
case COLUMN_ICON: case COLUMN_ICON:
return alias.getIconName(); return alias.getIconName();
case COLUMN_COLOR: case COLUMN_COLOR:
return alias.getColor(); return alias.getColor();
} }
return null; return null;
} }
@Override @Override
public void setValueAt( Object aValue, int rowIndex, int columnIndex ) public void setValueAt(Object aValue, int rowIndex, int columnIndex)
{ {
throw new IllegalArgumentException( "Not yet implemented" ); throw new IllegalArgumentException("Not yet implemented");
} }
public void broadcast( AliasEvent event ) public void broadcast(AliasEvent event)
{ {
Alias alias = event.getAlias(); Alias alias = event.getAlias();
//Validate the alias following a user action that changed the alias or any alias IDs //Validate the alias following a user action that changed the alias or any alias IDs
@@ -325,23 +328,23 @@ public class AliasModel extends AbstractTableModel
alias.validate(); alias.validate();
} }
if( event.getEvent() == Event.CHANGE ) if(event.getEvent() == Event.CHANGE)
{ {
int index = mAliases.indexOf( event.getAlias() ); int index = mAliases.indexOf(event.getAlias());
fireTableRowsUpdated( index, index ); fireTableRowsUpdated(index, index);
} }
mAliasEventBroadcaster.broadcast( event ); mAliasEventBroadcaster.broadcast(event);
} }
public void addListener( Listener<AliasEvent> listener ) public void addListener(Listener<AliasEvent> listener)
{ {
mAliasEventBroadcaster.addListener( listener ); mAliasEventBroadcaster.addListener(listener);
} }
public void removeListener( Listener<AliasEvent> listener ) public void removeListener(Listener<AliasEvent> listener)
{ {
mAliasEventBroadcaster.removeListener( listener ); mAliasEventBroadcaster.removeListener(listener);
} }
} }