private static DatabaseArticleType instance;
private static SimpleList articletypePopupData;
- public static DatabaseArticleType getInstance() throws StorageObjectException
+ // the following *has* to be sychronized cause this static method
+ // could get preemted and we could end up with 2 instances of DatabaseFoo..
+ // see the "Singletons with needles and thread" article at JavaWorld -mh
+ public synchronized static DatabaseArticleType getInstance()
+ throws StorageObjectException
{
if (instance == null) {
instance = new DatabaseArticleType();
private static DatabaseAudio instance;
private static SimpleList publisherPopupData;
- public static DatabaseAudio getInstance() throws StorageObjectException
+ // the following *has* to be sychronized cause this static method
+ // could get preemted and we could end up with 2 instances of DatabaseFoo..
+ // see the "Singletons with needles and thread" article at JavaWorld -mh
+ public synchronized static DatabaseAudio getInstance()
+ throws StorageObjectException
{
if (instance == null) {
instance = new DatabaseAudio();
private static DatabaseBreaking instance;
- public static DatabaseBreaking getInstance() throws StorageObjectException {
+ // the following *has* to be sychronized cause this static method
+ // could get preemted and we could end up with 2 instances of DatabaseFoo..
+ // see the "Singletons with needles and thread" article at JavaWorld -mh
+ public synchronized static DatabaseBreaking getInstance()
+ throws StorageObjectException {
if (instance == null) {
instance = new DatabaseBreaking();
instance.myselfDatabase = instance;
private static DatabaseComment instance;
- public static DatabaseComment getInstance() throws StorageObjectException {
+ // the following *has* to be sychronized cause this static method
+ // could get preemted and we could end up with 2 instances of DatabaseFoo..
+ // see the "Singletons with needles and thread" article at JavaWorld -mh
+ public synchronized static DatabaseComment getInstance()
+ throws StorageObjectException {
if (instance == null) {
instance = new DatabaseComment();
instance.myselfDatabase = instance;
private static DatabaseFeature instance;
- public static DatabaseFeature getInstance() throws StorageObjectException {
+ // the following *has* to be sychronized cause this static method
+ // could get preemted and we could end up with 2 instances of DatabaseFoo..
+ // see the "Singletons with needles and thread" article at JavaWorld -mh
+ public synchronized static DatabaseFeature getInstance()
+ throws StorageObjectException {
if (instance == null) {
instance = new DatabaseFeature();
instance.myselfDatabase = instance;
private static DatabaseImageColor instance;
private static SimpleList publisherPopupData;
- public static DatabaseImageColor getInstance() throws StorageObjectException
+ // the following *has* to be sychronized cause this static method
+ // could get preemted and we could end up with 2 instances of DatabaseFoo..
+ // see the "Singletons with needles and thread" article at JavaWorld -mh
+ public synchronized static DatabaseImageColor getInstance()
+ throws StorageObjectException
{
if (instance == null) {
instance = new DatabaseImageColor();
private static DatabaseImageFormat instance;
private static SimpleList publisherPopupData;
- public static DatabaseImageFormat getInstance() throws StorageObjectException
+ // the following *has* to be sychronized cause this static method
+ // could get preemted and we could end up with 2 instances of DatabaseFoo..
+ // see the "Singletons with needles and thread" article at JavaWorld -mh
+ public synchronized static DatabaseImageFormat getInstance()
+ throws StorageObjectException
{
if (instance == null) {
instance = new DatabaseImageFormat();
private static DatabaseImageLayout instance;
private static SimpleList publisherPopupData;
- public static DatabaseImageLayout getInstance() throws StorageObjectException
+ // the following *has* to be sychronized cause this static method
+ // could get preemted and we could end up with 2 instances of DatabaseFoo..
+ // see the "Singletons with needles and thread" article at JavaWorld -mh
+ public synchronized static DatabaseImageLayout getInstance()
+ throws StorageObjectException
{
if (instance == null) {
instance = new DatabaseImageLayout();
private static DatabaseImageType instance;
private static SimpleList publisherPopupData;
- public static DatabaseImageType getInstance() throws StorageObjectException
+ // the following *has* to be sychronized cause this static method
+ // could get preemted and we could end up with 2 instances of DatabaseFoo..
+ // see the "Singletons with needles and thread" article at JavaWorld -mh
+ public synchronized static DatabaseImageType getInstance()
+ throws StorageObjectException
{
if (instance == null) {
instance = new DatabaseImageType();
private static DatabaseImages instance;
private static SimpleList publisherPopupData;
- public static DatabaseImages getInstance() throws StorageObjectException
+ // the following *has* to be sychronized cause this static method
+ // could get preemted and we could end up with 2 instances of DatabaseFoo..
+ // see the "Singletons with needles and thread" article at JavaWorld -mh
+ public synchronized static DatabaseImages getInstance()
+ throws StorageObjectException
{
if (instance == null) {
instance = new DatabaseImages();
private static DatabaseLanguage instance;
private static SimpleList languagePopupData;
- public static DatabaseLanguage getInstance() throws StorageObjectException
+ // the following *has* to be sychronized cause this static method
+ // could get preemted and we could end up with 2 instances of DatabaseFoo..
+ // see the "Singletons with needles and thread" article at JavaWorld -mh
+ public synchronized static DatabaseLanguage getInstance()
+ throws StorageObjectException
{
if (instance == null) {
instance = new DatabaseLanguage();
* @return
* @exception StorageObjectException
*/
- public static DatabaseLinksImcs getInstance () throws StorageObjectException {
+ // the following *has* to be sychronized cause this static method
+ // could get preemted and we could end up with 2 instances of DatabaseFoo..
+ // see the "Singletons with needles and thread" article at JavaWorld -mh
+ public synchronized static DatabaseLinksImcs getInstance ()
+ throws StorageObjectException {
if (instance == null) {
instance = new DatabaseLinksImcs();
instance.myselfDatabase = instance;
private static DatabaseMedia instance;
private static EntityRelation relationMediaType;
- public static DatabaseMedia getInstance() throws StorageObjectException {
+ // the following *has* to be sychronized cause this static method
+ // could get preemted and we could end up with 2 instances of DatabaseFoo..
+ // see the "Singletons with needles and thread" article at JavaWorld -mh
+ public synchronized static DatabaseMedia getInstance()
+ throws StorageObjectException {
if (instance == null) {
instance = new DatabaseMedia();
instance.myselfDatabase = instance;
private static DatabaseMediaType instance;
- public static DatabaseMediaType getInstance() throws StorageObjectException {
+ // the following *has* to be sychronized cause this static method
+ // could get preemted and we could end up with 2 instances of DatabaseFoo..
+ // see the "Singletons with needles and thread" article at JavaWorld -mh
+ public synchronized static DatabaseMediaType getInstance()
+ throws StorageObjectException {
if (instance == null) {
instance = new DatabaseMediaType();
instance.myselfDatabase = instance;
private static DatabaseMediafolder instance;
- public static DatabaseMediafolder getInstance() throws StorageObjectException {
+ // the following *has* to be sychronized cause this static method
+ // could get preemted and we could end up with 2 instances of DatabaseFoo..
+ // see the "Singletons with needles and thread" article at JavaWorld -mh
+ public synchronized static DatabaseMediafolder getInstance()
+ throws StorageObjectException {
if (instance == null) {
instance = new DatabaseMediafolder();
instance.myselfDatabase = instance;
private static DatabaseMessages instance;
- public static DatabaseMessages getInstance() throws StorageObjectException {
+ // the following *has* to be sychronized cause this static method
+ // could get preemted and we could end up with 2 instances of DatabaseFoo..
+ // see the "Singletons with needles and thread" article at JavaWorld -mh
+ public synchronized static DatabaseMessages getInstance()
+ throws StorageObjectException {
if (instance == null) {
instance = new DatabaseMessages();
instance.myselfDatabase = instance;
private static DatabaseOther instance;
private static SimpleList publisherPopupData;
- public static DatabaseOther getInstance() throws StorageObjectException
+ // the following *has* to be sychronized cause this static method
+ // could get preemted and we could end up with 2 instances of DatabaseFoo..
+ // see the "Singletons with needles and thread" article at JavaWorld -mh
+ public synchronized static DatabaseOther getInstance()
+ throws StorageObjectException
{
if (instance == null) {
instance = new DatabaseOther();
private static DatabaseRights instance;
private static SimpleList publisherPopupData;
- public static DatabaseRights getInstance() throws StorageObjectException
+ // the following *has* to be sychronized cause this static method
+ // could get preemted and we could end up with 2 instances of DatabaseFoo..
+ // see the "Singletons with needles and thread" article at JavaWorld -mh
+ public synchronized static DatabaseRights getInstance()
+ throws StorageObjectException
{
if (instance == null) {
instance = new DatabaseRights();
private static DatabaseTopics instance;
- public static DatabaseTopics getInstance() throws StorageObjectException {
+ // the following *has* to be sychronized cause this static method
+ // could get preemted and we could end up with 2 instances of DatabaseFoo..
+ // see the "Singletons with needles and thread" article at JavaWorld -mh
+ public synchronized static DatabaseTopics getInstance()
+ throws StorageObjectException {
if (instance == null) {
instance = new DatabaseTopics();
instance.myselfDatabase = instance;
private static DatabaseUsers instance;
- public static DatabaseUsers getInstance() throws StorageObjectException {
+ // the following *has* to be sychronized cause this static method
+ // could get preemted and we could end up with 2 instances of DatabaseFoo..
+ // see the "Singletons with needles and thread" article at JavaWorld -mh
+ public synchronized static DatabaseUsers getInstance()
+ throws StorageObjectException {
if (instance == null) {
instance = new DatabaseUsers();
instance.myselfDatabase = instance;
private static DatabaseVideo instance;
private static SimpleList publisherPopupData;
- public static DatabaseVideo getInstance() throws StorageObjectException
+ // the following *has* to be sychronized cause this static method
+ // could get preemted and we could end up with 2 instances of DatabaseFoo..
+ // see the "Singletons with needles and thread" article at JavaWorld -mh
+ public synchronized static DatabaseVideo getInstance()
+ throws StorageObjectException
{
if (instance == null) {
instance = new DatabaseVideo();