Determine if an icon relationship exists for the feature table

@param featureTable
feature table
@return true if relationship exists
971261
public boolean hasIconRelationship(String featureTable) {
		return hasStyleRelationship(
				getMappingTableName(TABLE_MAPPING_ICON, featureTable),
				featureTable, IconTable.TABLE_NAME);
	}
59862
public Extensions create(FeatureTable featureTable) {
		return create(featureTable.getTableName(), featureTable
				.getGeometryColumn().getName(), featureTable.getPkColumn()
				.getName());
	}
1225372
@TargetApi(Build.VERSION_CODES.HONEYCOMB_MR2)
    public static boolean hasLandscapeScreenFeature(Context context) {
        return hasLandscapeScreenFeature(context.getPackageManager());
    }
109944
public List<FeatureTileLink> queryForTileTableName(String tileTableName) {
		List<FeatureTileLink> results = null;
		try {
			results = queryForEq(FeatureTileLink.COLUMN_TILE_TABLE_NAME,
					tileTableName);
		} catch (SQLException e) {
			throw new GeoPackageException(
					"Failed to query for Feature Tile Link objects by Tile Table Name: "
							+ tileTableName);
		}
		return results;
	}
1359220
@SuppressWarnings("unchecked")
    @Override
    public Collection<FeatureCollectionAsset> getFeatureCollections(String productId, String productVersion, String productInstallType, String productLicenseType,
                                                                    String productEdition) {
        return (Collection<FeatureCollectionAsset>) getEsaAsset(productId, productVersion, productInstallType, productLicenseType, productEdition,
                                                                Visibility.INSTALL);
    }
808919
public void link(String featureTable, String tileTable) {

		if (!isLinked(featureTable, tileTable)) {
			getOrCreateExtension();

			try {
				if (!featureTileLinkDao.isTableExists()) {
					geoPackage.createFeatureTileLinkTable();
				}

				FeatureTileLink link = new FeatureTileLink();
				link.setFeatureTableName(featureTable);
				link.setTileTableName(tileTable);

				featureTileLinkDao.create(link);
			} catch (SQLException e) {
				throw new GeoPackageException(
						"Failed to create feature tile link for GeoPackage: "
								+ geoPackage.getName() + ", Feature Table: "
								+ featureTable + ", Tile Table: " + tileTable,
						e);
			}
		}
	}
567313
@Override
	public boolean supports(LookupContext context) {

		Relation relation = lookupAnnotation(context.getType());

		if (relation == null) {
			return false;
		}

		if (context.isItemRelationLookup()) {
			return !relation.value().equals(Relation.NO_RELATION);
		}

		if (context.isCollectionRelationLookup()) {
			return !relation.collectionRelation().equals(Relation.NO_RELATION);
		}

		return false;
	}
1269310
public void createTableStyleRelationship(String featureTable) {
		createStyleRelationship(
				getMappingTableName(TABLE_MAPPING_TABLE_STYLE, featureTable),
				featureTable, ContentsId.TABLE_NAME, StyleTable.TABLE_NAME);
	}
976961
@TargetApi(Build.VERSION_CODES.HONEYCOMB_MR2)
    public static boolean hasLandscapeScreenFeature(PackageManager manager) {
        return manager.hasSystemFeature(PackageManager.FEATURE_SCREEN_LANDSCAPE);
    }
227512
@TargetApi(Build.VERSION_CODES.KITKAT)
    public static boolean hasDeviceAdminFeature(PackageManager manager) {
        return manager.hasSystemFeature(PackageManager.FEATURE_DEVICE_ADMIN);
    }
735325
private boolean hasInterface(Class c, String targetClassName)
   {
      for (Class face : c.getInterfaces())
      {
         if (face.getName().equals(targetClassName))
         {
            return true;
         }
         else
         {
            for (Class face2 : face.getInterfaces())
            {
               if (face2.getName().equals(targetClassName))
               {
                  return true;
               }
               else if (hasInterface(face2, targetClassName))
               {
                  return true;
               }
            }
         }
      }
      if (null != c.getSuperclass())
      {
         return hasInterface(c.getSuperclass(), targetClassName);
      }
      return false;
   }
537862
@Override
    public boolean match(Statement s) {
        if (s.getObject() == null) {
            return false;
        }
        if (s.getObject().getTerm() == null) {
            return false;
        }
        final RelationshipType r = s.getRelationshipType();
        if (!r.isDirected()) {
            return true;
        }
        return false;
    }
1201557
public static void deleteFeatureStyle(GeoPackageCore geoPackage,
			String table) {

		FeatureCoreStyleExtension featureStyleExtension = getFeatureStyleExtension(geoPackage);
		if (featureStyleExtension.has(table)) {
			featureStyleExtension.deleteRelationships(table);
		}

	}
849283
private static FeatureCoreStyleExtension getFeatureStyleExtension(
			GeoPackageCore geoPackage) {

		RelatedTablesCoreExtension relatedTables = new RelatedTablesCoreExtension(
				geoPackage) {
			@Override
			public String getPrimaryKeyColumnName(String tableName) {
				return null;
			}
		};

		return new FeatureCoreStyleExtension(geoPackage, relatedTables) {
		};
	}
142623
public static boolean isRelationshipParsable(JsonNode dataNode) {
		return dataNode != null && dataNode.hasNonNull(JSONAPISpecConstants.ID) && dataNode.hasNonNull(JSONAPISpecConstants.TYPE) &&
				!dataNode.get(JSONAPISpecConstants.ID).isContainerNode() && !dataNode.get(JSONAPISpecConstants.TYPE).isContainerNode();
	}
857236
public boolean hasRelationship(String featureTable) {
		return hasStyleRelationship(featureTable)
				|| hasTableStyleRelationship(featureTable)
				|| hasIconRelationship(featureTable)
				|| hasTableIconRelationship(featureTable);
	}
71444
public boolean exists(long featureId, String database, String table) {
        boolean exists = false;
        Map<String, Map<Long, FeatureShape>> tables = databases.get(database);
        if (tables != null) {

            Map<Long, FeatureShape> featureIds = tables.get(table);
            if (featureIds != null) {
                FeatureShape shapes = featureIds.get(featureId);
                exists = shapes != null && shapes.hasShapes();
            }
        }
        return exists;
    }