1 package javax.jdo.stub; 2 3 import java.util.Collection; 4 import java.util.Map; 5 import java.util.Properties; 6 import java.util.Set; 7 8 import javax.jdo.Constants; 9 import javax.jdo.FetchGroup; 10 import javax.jdo.PersistenceManager; 11 import javax.jdo.PersistenceManagerFactory; 12 import javax.jdo.datastore.DataStoreCache; 13 import javax.jdo.listener.InstanceLifecycleListener; 14 import javax.jdo.metadata.JDOMetadata; 15 import javax.jdo.metadata.TypeMetadata; 16 17 public class StubPMF implements PersistenceManagerFactory, Constants { 18 19 public static final String PROPERTY_TRANSACTION_TYPE = "javax.jdo.option.TransactionType"; 20 21 public static PersistenceManagerFactory getPersistenceManagerFactory( 22 Map props) { 23 24 StubPMF pmf = new StubPMF(); 25 26 pmf.setProperties(props); 27 28 for (Object key : props.keySet()) { 29 if (!(key instanceof String)) { 30 continue; 31 } 32 String prop = (String) key; 33 if (!prop.startsWith("javax.jdo.")) { 34 continue; 35 } 36 pmf.setProperty(prop, props.get(prop)); 37 } 38 39 return pmf; 40 } 41 42 public static PersistenceManagerFactory getPersistenceManagerFactory( 43 Map overrides, Map props) { 44 45 StubPMF pmf = new StubPMF(); 46 47 pmf.setProperties(props); 48 pmf.setProperties(overrides); 49 50 return pmf; 51 } 52 53 String name; 54 String persistenceManagerFactoryClassName; 55 String spiResourceName; 56 String optionConnectionUserName; 57 String optionConnectionPassword; 58 String optionConnectionURL; 59 String optionConnectionDriverName; 60 String optionConnectionFactoryName; 61 Object optionConnectionFactory; 62 String optionConnectionFactory2Name; 63 Object optionConnectionFactory2; 64 boolean optionMultithreaded; 65 String optionMapping; 66 boolean optionOptimistic; 67 boolean optionRetainValues; 68 boolean optionRestoreValues; 69 boolean optionNontransactionalRead; 70 boolean optionNontransactionalWrite; 71 boolean optionIgnoreCache; 72 boolean optionDetachAllOnCommit; 73 boolean optionCopyOnAttach; 74 String optionName; 75 String optionPersistenceUnitName; 76 String optionServerTimeZoneID; 77 String optionTransactionType; 78 boolean optionReadOnly; 79 String optionTransactionIsolationLevel; 80 Integer optionDatastoreReadTimeoutMillis; 81 Integer optionDatastoreWriteTimeoutMillis; 82 83 Properties properties = new Properties(); 84 85 public String getConnectionUserName() { 86 return optionConnectionUserName; 87 } 88 89 public void setConnectionUserName(String connectionUserName) { 90 this.optionConnectionUserName = connectionUserName; 91 } 92 93 public void setConnectionPassword(String connectionPassword) { 94 this.optionConnectionPassword = connectionPassword; 95 } 96 97 public String getConnectionURL() { 98 return optionConnectionURL; 99 } 100 101 public void setConnectionURL(String connectionURL) { 102 this.optionConnectionURL = connectionURL; 103 } 104 105 public String getConnectionDriverName() { 106 return optionConnectionDriverName; 107 } 108 109 public void setConnectionDriverName(String connectionDriverName) { 110 this.optionConnectionDriverName = connectionDriverName; 111 } 112 113 public String getConnectionFactoryName() { 114 return optionConnectionFactoryName; 115 } 116 117 public void setConnectionFactoryName(String connectionFactoryName) { 118 this.optionConnectionFactoryName = connectionFactoryName; 119 } 120 121 public Object getConnectionFactory() { 122 return optionConnectionFactory; 123 } 124 125 public void setConnectionFactory(Object connectionFactory) { 126 this.optionConnectionFactory = connectionFactory; 127 } 128 129 public String getConnectionFactory2Name() { 130 return optionConnectionFactory2Name; 131 } 132 133 public void setConnectionFactory2Name(String connectionFactory2Name) { 134 this.optionConnectionFactory2Name = connectionFactory2Name; 135 } 136 137 public Object getConnectionFactory2() { 138 return optionConnectionFactory2; 139 } 140 141 public void setConnectionFactory2(Object connectionFactory2) { 142 this.optionConnectionFactory2 = connectionFactory2; 143 } 144 145 public boolean getMultithreaded() { 146 return optionMultithreaded; 147 } 148 149 public void setMultithreaded(boolean multithreaded) { 150 this.optionMultithreaded = multithreaded; 151 } 152 153 public String getMapping() { 154 return optionMapping; 155 } 156 157 public void setMapping(String mapping) { 158 this.optionMapping = mapping; 159 } 160 161 public boolean getOptimistic() { 162 return optionOptimistic; 163 } 164 165 public void setOptimistic(boolean optimistic) { 166 this.optionOptimistic = optimistic; 167 } 168 169 public boolean getRetainValues() { 170 return optionRetainValues; 171 } 172 173 public void setRetainValues(boolean retainValues) { 174 this.optionRetainValues = retainValues; 175 } 176 177 public boolean getRestoreValues() { 178 return optionRestoreValues; 179 } 180 181 public void setRestoreValues(boolean restoreValues) { 182 this.optionRestoreValues = restoreValues; 183 } 184 185 public boolean getNontransactionalRead() { 186 return optionNontransactionalRead; 187 } 188 189 public void setNontransactionalRead(boolean nontransactionalRead) { 190 this.optionNontransactionalRead = nontransactionalRead; 191 } 192 193 public boolean getNontransactionalWrite() { 194 return optionNontransactionalWrite; 195 } 196 197 public void setNontransactionalWrite(boolean nontransactionalWrite) { 198 this.optionNontransactionalWrite = nontransactionalWrite; 199 } 200 201 public boolean getIgnoreCache() { 202 return optionIgnoreCache; 203 } 204 205 public void setIgnoreCache(boolean ignoreCache) { 206 this.optionIgnoreCache = ignoreCache; 207 } 208 209 public boolean getDetachAllOnCommit() { 210 return optionDetachAllOnCommit; 211 } 212 213 public void setDetachAllOnCommit(boolean detachAllOnCommit) { 214 this.optionDetachAllOnCommit = detachAllOnCommit; 215 } 216 217 public boolean getCopyOnAttach() { 218 return optionCopyOnAttach; 219 } 220 221 public void setCopyOnAttach(boolean copyOnAttach) { 222 this.optionCopyOnAttach = copyOnAttach; 223 } 224 225 public String getName() { 226 return optionName; 227 } 228 229 public void setName(String name) { 230 this.optionName = name; 231 } 232 233 public String getPersistenceUnitName() { 234 return optionPersistenceUnitName; 235 } 236 237 public void setPersistenceUnitName(String persistenceUnitName) { 238 this.optionPersistenceUnitName = persistenceUnitName; 239 } 240 241 public String getServerTimeZoneID() { 242 return optionServerTimeZoneID; 243 } 244 245 public void setServerTimeZoneID(String serverTimeZoneID) { 246 this.optionServerTimeZoneID = serverTimeZoneID; 247 } 248 249 public String getTransactionType() { 250 return optionTransactionType; 251 } 252 253 public void setTransactionType(String transactionType) { 254 this.optionTransactionType = transactionType; 255 } 256 257 public boolean getReadOnly() { 258 return optionReadOnly; 259 } 260 261 public void setReadOnly(boolean readOnly) { 262 this.optionReadOnly = readOnly; 263 } 264 265 public String getTransactionIsolationLevel() { 266 return optionTransactionIsolationLevel; 267 } 268 269 public void setTransactionIsolationLevel(String transactionIsolationLevel) { 270 this.optionTransactionIsolationLevel = transactionIsolationLevel; 271 } 272 273 public Integer getDatastoreReadTimeoutMillis() { 274 return optionDatastoreReadTimeoutMillis; 275 } 276 277 public void setDatastoreReadTimeoutMillis(Integer datastoreReadTimeoutMillis) { 278 this.optionDatastoreReadTimeoutMillis = datastoreReadTimeoutMillis; 279 } 280 281 public Integer getDatastoreWriteTimeoutMillis() { 282 return optionDatastoreWriteTimeoutMillis; 283 } 284 285 public void setDatastoreWriteTimeoutMillis( 286 Integer datastoreWriteTimeoutMillis) { 287 this.optionDatastoreWriteTimeoutMillis = datastoreWriteTimeoutMillis; 288 } 289 290 public void close() { 291 throw new UnsupportedOperationException("not implemented"); 292 } 293 294 public boolean isClosed() { 295 return true; 296 } 297 298 public PersistenceManager getPersistenceManager() { 299 throw new UnsupportedOperationException("not implemented"); 300 } 301 302 public PersistenceManager getPersistenceManagerProxy() { 303 throw new UnsupportedOperationException("not implemented"); 304 } 305 306 public PersistenceManager getPersistenceManager(String userid, 307 String password) { 308 throw new UnsupportedOperationException("not implemented"); 309 } 310 311 public Properties getProperties() { 312 return properties; 313 } 314 315 public Collection<String> supportedOptions() { 316 throw new UnsupportedOperationException("not implemented"); 317 } 318 319 public DataStoreCache getDataStoreCache() { 320 return new DataStoreCache() { 321 322 public void evict(Object oid) { 323 } 324 325 public void evictAll() { 326 } 327 328 public void evictAll(Object... oids) { 329 } 330 331 public void evictAll(Collection oids) { 332 } 333 334 public void evictAll(Class pcClass, boolean subclasses) { 335 } 336 337 public void evictAll(boolean subclasses, Class pcClass) { 338 } 339 340 public void pin(Object oid) { 341 } 342 343 public void pinAll(Collection oids) { 344 } 345 346 public void pinAll(Object... oids) { 347 } 348 349 public void pinAll(Class pcClass, boolean subclasses) { 350 } 351 352 public void pinAll(boolean subclasses, Class pcClass) { 353 } 354 355 public void unpin(Object oid) { 356 } 357 358 public void unpinAll(Collection oids) { 359 } 360 361 public void unpinAll(Object... oids) { 362 } 363 364 public void unpinAll(Class pcClass, boolean subclasses) { 365 } 366 367 public void unpinAll(boolean subclasses, Class pcClass) { 368 } 369 }; 370 } 371 372 public void addInstanceLifecycleListener( 373 InstanceLifecycleListener listener, Class[] classes) { 374 throw new UnsupportedOperationException("not implemented"); 375 } 376 377 public void removeInstanceLifecycleListener( 378 InstanceLifecycleListener listener) { 379 throw new UnsupportedOperationException("not implemented"); 380 } 381 382 public void addFetchGroups(FetchGroup... groups) { 383 throw new UnsupportedOperationException("not implemented"); 384 } 385 386 public void removeFetchGroups(FetchGroup... groups) { 387 throw new UnsupportedOperationException("not implemented"); 388 } 389 390 public void removeAllFetchGroups() { 391 throw new UnsupportedOperationException("not implemented"); 392 } 393 394 @SuppressWarnings("rawtypes") 395 public FetchGroup getFetchGroup(Class cls, String name) { 396 throw new UnsupportedOperationException("not implemented"); 397 } 398 399 @SuppressWarnings("rawtypes") 400 public Set getFetchGroups() { 401 throw new UnsupportedOperationException("not implemented"); 402 } 403 404 public void registerMetadata(JDOMetadata metadata) { 405 throw new UnsupportedOperationException("not implemented"); 406 } 407 408 public JDOMetadata newMetadata() { 409 throw new UnsupportedOperationException("not implemented"); 410 } 411 412 public TypeMetadata getMetadata(String className) { 413 throw new UnsupportedOperationException("not implemented"); 414 } 415 416 void setSpiResourceName(String spiPropertiesResourceName) { 417 this.spiResourceName = spiPropertiesResourceName; 418 } 419 420 public String getSpiPropertiesResourceName() { 421 return spiResourceName; 422 } 423 424 void setPersistenceManagerFactoryClass(String className) { 425 this.persistenceManagerFactoryClassName = className; 426 } 427 428 public String getPersistenceManagerFactoryClass() { 429 return this.persistenceManagerFactoryClassName; 430 } 431 432 void setProperty(String name, Object value) { 433 434 String val = value.toString(); 435 436 if (name.equals(PROPERTY_PERSISTENCE_MANAGER_FACTORY_CLASS)) { 437 setPersistenceManagerFactoryClass(val); 438 return; 439 } 440 if (name.equals(PROPERTY_CONNECTION_DRIVER_NAME)) { 441 setConnectionDriverName(val); 442 return; 443 } 444 if (name.equals(PROPERTY_CONNECTION_FACTORY_NAME)) { 445 setConnectionFactoryName(val); 446 return; 447 } 448 if (name.equals(PROPERTY_CONNECTION_FACTORY2_NAME)) { 449 setConnectionFactory2Name(val); 450 return; 451 } 452 if (name.equals(PROPERTY_CONNECTION_PASSWORD)) { 453 setConnectionPassword(val); 454 return; 455 } 456 if (name.equals(PROPERTY_CONNECTION_URL)) { 457 setConnectionURL(val); 458 return; 459 } 460 if (name.equals(PROPERTY_CONNECTION_USER_NAME)) { 461 setConnectionUserName(val); 462 return; 463 } 464 if (name.equals(PROPERTY_IGNORE_CACHE)) { 465 setCopyOnAttach(Boolean.parseBoolean(val)); 466 return; 467 } 468 if (name.equals(PROPERTY_DATASTORE_READ_TIMEOUT_MILLIS)) { 469 setDatastoreReadTimeoutMillis(Integer.parseInt(val)); 470 return; 471 } 472 if (name.equals(PROPERTY_DATASTORE_WRITE_TIMEOUT_MILLIS)) { 473 setDatastoreWriteTimeoutMillis(Integer.parseInt(val)); 474 return; 475 } 476 if (name.equals(PROPERTY_DETACH_ALL_ON_COMMIT)) { 477 setDetachAllOnCommit(Boolean.parseBoolean(val)); 478 return; 479 } 480 if (name.equals(PROPERTY_IGNORE_CACHE)) { 481 setIgnoreCache(Boolean.parseBoolean(val)); 482 return; 483 } 484 if (name.equals(PROPERTY_MAPPING)) { 485 setMapping(val); 486 return; 487 } 488 if (name.equals(PROPERTY_MULTITHREADED)) { 489 setMultithreaded(Boolean.parseBoolean(val)); 490 return; 491 } 492 if (name.equals(PROPERTY_NAME)) { 493 setName(val); 494 return; 495 } 496 if (name.equals(PROPERTY_NONTRANSACTIONAL_READ)) { 497 setNontransactionalRead(Boolean.parseBoolean(val)); 498 return; 499 } 500 if (name.equals(PROPERTY_NONTRANSACTIONAL_WRITE)) { 501 setNontransactionalWrite(Boolean.parseBoolean(val)); 502 return; 503 } 504 if (name.equals(PROPERTY_OPTIMISTIC)) { 505 setOptimistic(Boolean.parseBoolean(val)); 506 return; 507 } 508 if (name.equals(PROPERTY_PERSISTENCE_UNIT_NAME)) { 509 setPersistenceUnitName(val); 510 return; 511 } 512 if (name.equals(PROPERTY_READONLY)) { 513 setReadOnly(Boolean.parseBoolean(val)); 514 return; 515 } 516 if (name.equals(PROPERTY_RESTORE_VALUES)) { 517 setRestoreValues(Boolean.parseBoolean(val)); 518 return; 519 } 520 if (name.equals(PROPERTY_RETAIN_VALUES)) { 521 setRetainValues(Boolean.parseBoolean(val)); 522 return; 523 } 524 if (name.equals(PROPERTY_SERVER_TIME_ZONE_ID)) { 525 setServerTimeZoneID(val); 526 return; 527 } 528 if (name.equals(PROPERTY_TRANSACTION_ISOLATION_LEVEL)) { 529 setTransactionIsolationLevel(val); 530 return; 531 } 532 if (name.equals(PROPERTY_TRANSACTION_TYPE)) { 533 setTransactionType(val); 534 return; 535 } 536 if (name.equals(PROPERTY_SPI_RESOURCE_NAME)) { 537 setSpiResourceName(val); 538 return; 539 } 540 541 throw new IllegalArgumentException("unhandled stub PMF property " 542 + name); 543 } 544 545 void setProperties(Map properties) { 546 for (Object key : properties.keySet()) { 547 String k = key.toString(); 548 Object v = properties.get(key); 549 550 this.properties.put(k, v); 551 setProperty(k, v); 552 } 553 554 } 555 }