static { try { String platform; if (isWindows()) { platform = "windows"; } else if (isUnix()) { platform = "linux"; } else if (isMac()) { platform = "mac"; } else { platform = null; } String propertiesFile = "undefined"; if (platform != null) { propertiesFile = "org/python/pydev/core/TestDependent." + platform + ".properties"; InputStream stream = TestDependent.class.getClassLoader().getResourceAsStream(propertiesFile); if (stream != null) { // Initialize the static contents of the class. String streamContents = REF.getStreamContents(stream, null, null); Properties props = PropertiesHelper.createPropertiesFromString(streamContents); Map<String, String> map = PropertiesHelper.createMapFromProperties(props); Set<Entry<String, String>> entrySet = map.entrySet(); for (Entry<String, String> entry : entrySet) { String key = entry.getKey(); try { Field field = TestDependent.class.getField(key); if (field != null) { String value = entry.getValue(); if (!value.equals("null")) { field.set(null, value); } } } catch (Exception e) { e.printStackTrace(); } } } else { System.err.println( "Could not get stream to: " + propertiesFile + " to initialize TestDependent.java values."); } } // Checking and setting variables that do not exist (if possible). if (PYTHON_INSTALL == null) { System.err.println( "PYTHON_INSTALL variable MUST be set in " + propertiesFile + " to run tests."); } else if (!new File(PYTHON_INSTALL).exists()) { System.err.println( "PYTHON_INSTALL variable points to path that does NOT exist: " + PYTHON_INSTALL); } if (TEST_PYDEV_BASE_LOC == null) { System.err.println( "TEST_PYDEV_BASE_LOC variable MUST be set in " + propertiesFile + " to run tests."); } else if (!new File(TEST_PYDEV_BASE_LOC).exists()) { System.err.println( "TEST_PYDEV_BASE_LOC variable points to path that does NOT exist: " + TEST_PYDEV_BASE_LOC); } if (PYTHON_EXE == null) { if (isWindows()) { PYTHON_EXE = PYTHON_INSTALL + "python.exe"; } else { PYTHON_EXE = PYTHON_INSTALL + "python"; } } if (!new File(PYTHON_EXE).exists()) { System.err.println("PYTHON_EXE variable points to path that does NOT exist: " + PYTHON_EXE); } if (PYTHON_LIB == null) { PYTHON_LIB = PYTHON_INSTALL + "Lib/"; } if (PYTHON_DLLS == null) { PYTHON_DLLS = PYTHON_INSTALL + "DLLs/"; } if (PYTHON_SITE_PACKAGES == null) { PYTHON_SITE_PACKAGES = PYTHON_LIB + "site-packages/"; } if (PYTHON_TEST_PACKAGES == null) { if (new File(TestDependent.PYTHON_LIB + "test/").exists()) { PYTHON_TEST_PACKAGES = TestDependent.PYTHON_LIB + "test/"; } } if (TEST_PYSRC_LOC == null) { TEST_PYSRC_LOC = TEST_PYDEV_BASE_LOC + "org.python.pydev/tests/pysrc/"; } if (TEST_PYSRC_NAVIGATOR_LOC == null) { TEST_PYSRC_NAVIGATOR_LOC = TEST_PYDEV_BASE_LOC + "org.python.pydev/tests_navigator/pysrc/"; } if (TEST_PYSRC_LOC2 == null) { TEST_PYSRC_LOC2 = TEST_PYDEV_BASE_LOC + "org.python.pydev/tests/pysrc2/"; } if (TEST_PYDEV_PLUGIN_LOC == null) { TEST_PYDEV_PLUGIN_LOC = TEST_PYDEV_BASE_LOC + "org.python.pydev/"; } if (TEST_PYDEV_DEBUG_PLUGIN_LOC == null) { TEST_PYDEV_DEBUG_PLUGIN_LOC = TEST_PYDEV_BASE_LOC + "org.python.pydev.debug/"; } if (TEST_PYDEV_JYTHON_PLUGIN_LOC == null) { TEST_PYDEV_JYTHON_PLUGIN_LOC = TEST_PYDEV_BASE_LOC + "org.python.pydev.jython/"; } if (TEST_PYDEV_PARSER_PLUGIN_LOC == null) { TEST_PYDEV_PARSER_PLUGIN_LOC = TEST_PYDEV_BASE_LOC + "org.python.pydev.parser/"; } if (TEST_PYDEV_REFACTORING_PLUGIN_LOC == null) { TEST_PYDEV_REFACTORING_PLUGIN_LOC = TEST_PYDEV_BASE_LOC + "org.python.pydev.refactoring/"; } if (TEST_COM_REFACTORING_PYSRC_LOC == null) { TEST_COM_REFACTORING_PYSRC_LOC = TEST_PYDEV_BASE_LOC + "com.python.pydev.refactoring/tests/pysrcrefactoring/"; } } catch (Exception e) { System.err.println( "--- Error getting contents to properly initialize TestDependent.java values ---"); e.printStackTrace(); } }
public Double getDouble(String key, Double defValue) { return PropertiesHelper.getDouble(map.get(key), defValue); }
/** * Updates the current list of {@link Property} instances, held by an {@link * Entity#getProperties()} instance, by appending {@link Property} instance(s) of types * represented by the {@link PropertiesUpdateHelper#getRelation()} instance */ public void updateProperties() { String[] jpaAnnotationTypesArr = null; Properties oneEndEntityPropertiesWrapper = null; Properties manyEndEntityPropertiesWrapper = null; One one = relation.getOne(); Many many = relation.getMany(); String oneEndEntityType = one.getType(); String manyEndEntityType = many.getType(); String propertyName = null; String propertyType = null; String genericTypeParameter = null; String mappedBy = null; String oneToOnePrimaryEntityPropertyName = null; String[] addTypesFullNameShortName = null; boolean isEntityJPAEnabled = false; switch (relationType) { case ONE_TO_MANY: // Create collectionType property and add it to "one" end // entity properties list String collectionType = many.getCollectionType(); // In this case two types needs to be added to the related entity // 1. the type of property // 2. the type of collection // And both of these should be present in import statements addTypesFullNameShortName = new String[] {manyEndEntityType, collectionType}; oneEndEntityPropertiesWrapper = entityFullyQualifiedNamePropertiesMap.get(oneEndEntityType); propertyName = PropertiesHelper.createPropertyNameForCollectionTypeRelatedEntity(many); propertyType = collectionType; genericTypeParameter = manyEndEntityType; isEntityJPAEnabled = entityFullyQualifiedNameIsJPAEnabledMap.get(oneEndEntityType); if (isEntityJPAEnabled) { jpaAnnotationTypesArr = new String[] { JPAAnnotationsMarkerHelper.getRelationTypeFullyQualifiedName(relationType), JPAConstants.CASCADE_ENUM_TYPE }; if (relation.isBidirectional()) { mappedBy = PropertiesHelper.createPropertyNameFromTypeName(oneEndEntityType); } } createAndAddProperty( CREATE_COLLECTION_TYPE_PROPERTY, propertyName, propertyType, relationType, jpaAnnotationTypesArr, genericTypeParameter, mappedBy, oneToOnePrimaryEntityPropertyName, oneEndEntityPropertiesWrapper, addTypesFullNameShortName); break; case MANY_TO_ONE: // Create "one" end entity type property and add it to // "many" end entity properties list addTypesFullNameShortName = new String[] {oneEndEntityType}; manyEndEntityPropertiesWrapper = entityFullyQualifiedNamePropertiesMap.get(manyEndEntityType); propertyName = PropertiesHelper.createPropertyNameFromTypeName(oneEndEntityType); propertyType = oneEndEntityType; isEntityJPAEnabled = entityFullyQualifiedNameIsJPAEnabledMap.get(manyEndEntityType); if (isEntityJPAEnabled) { jpaAnnotationTypesArr = new String[] { JPAAnnotationsMarkerHelper.getRelationTypeFullyQualifiedName(relationType), JPAConstants.CASCADE_ENUM_TYPE }; } createAndAddProperty( CREATE_PROPERTY, propertyName, propertyType, relationType, jpaAnnotationTypesArr, genericTypeParameter, mappedBy, oneToOnePrimaryEntityPropertyName, manyEndEntityPropertiesWrapper, addTypesFullNameShortName); break; case ONE_TO_ONE: // =============== PRIMARY ENTITY // Create "many" end entity type property and add it to // "one" end entity properties list // The "one" end entity is considered as Primary entity in one-to-one // relation and the entity at "many" end is considered as // Non-Primary entity. addTypesFullNameShortName = new String[] {manyEndEntityType}; oneEndEntityPropertiesWrapper = entityFullyQualifiedNamePropertiesMap.get(oneEndEntityType); propertyName = PropertiesHelper.createPropertyNameFromTypeName(manyEndEntityType); propertyType = manyEndEntityType; isEntityJPAEnabled = entityFullyQualifiedNameIsJPAEnabledMap.get(oneEndEntityType); if (isEntityJPAEnabled) { // The Primary entity requires the "cascade" attribute // The Primary entity requires javax.persistence.PrimaryKeyJoinColumn annotation jpaAnnotationTypesArr = new String[] { JPAAnnotationsMarkerHelper.getRelationTypeFullyQualifiedName(relationType), JPAConstants.CASCADE_ENUM_TYPE, JPAConstants.PRIMARY_KEY_JOIN_COLUMN_TYPE }; } createAndAddProperty( CREATE_PROPERTY, propertyName, propertyType, relationType, jpaAnnotationTypesArr, genericTypeParameter, mappedBy, oneToOnePrimaryEntityPropertyName, oneEndEntityPropertiesWrapper, addTypesFullNameShortName); // =============== NON-PRIMARY ENTITY // Create "one" end entity type property in "many" end entity // and add it to "many" end entity properties list addTypesFullNameShortName = new String[] {oneEndEntityType}; manyEndEntityPropertiesWrapper = entityFullyQualifiedNamePropertiesMap.get(manyEndEntityType); propertyName = PropertiesHelper.createPropertyNameFromTypeName(oneEndEntityType); propertyType = oneEndEntityType; isEntityJPAEnabled = entityFullyQualifiedNameIsJPAEnabledMap.get(manyEndEntityType); if (isEntityJPAEnabled) { // The Non-Primary entity does not require the "cascade" attribute // Thus not added the javax.persistence.CascadeType type to // jpaAnnotationTypesArr jpaAnnotationTypesArr = new String[] { JPAAnnotationsMarkerHelper.getRelationTypeFullyQualifiedName(relationType) }; // The Non-Primary entity requires the "mappedBy" attribute on // the "one" end entity type property added to non-primary // entity's current properties list mappedBy = PropertiesHelper.createPropertyNameFromTypeName(manyEndEntityType); } createAndAddProperty( CREATE_PROPERTY, propertyName, propertyType, relationType, jpaAnnotationTypesArr, genericTypeParameter, mappedBy, oneToOnePrimaryEntityPropertyName, manyEndEntityPropertiesWrapper, addTypesFullNameShortName); if (isEntityJPAEnabled) { // =============== NON-PRIMARY ENTITY // Add "id" property in "many" end entity with required annotations // for making the One-to-One relation work correctly. // Example: // @Id // @Column(name = "booking_id", unique = true, nullable = false)//TODO: this remains in // case of Id property for one-to-one non-primary entity // @GeneratedValue(generator="foreign") // @GenericGenerator(name="foreign", strategy = "foreign", parameters={ // @Parameter(name="property", // value="<PRIMARY_ENTITY_PROPERTY_NAME_ADDED_IN_NON_PRIMARY_ENTITY>") // }) // private Long id; jpaAnnotationTypesArr = new String[] { JPAConstants.ID_TYPE, JPAConstants.GENERATED_VALUE_TYPE, HibernateORMConstants.GENERIC_GENERATOR_TYPE, HibernateORMConstants.PARAMETER_TYPE }; propertyName = UtilityConstants.ID_PROPERTY_NAME; propertyType = UtilityConstants.ID_PROPERTY_DEFAULT_TYPE; oneToOnePrimaryEntityPropertyName = PropertiesHelper.createPropertyNameFromTypeName(oneEndEntityType); createAndAddProperty( CREATE_ONE_TO_ONE_RELATED_NON_PRIMARY_ENTITY_ID_PROPERTY, propertyName, propertyType, relationType, jpaAnnotationTypesArr, genericTypeParameter, mappedBy, oneToOnePrimaryEntityPropertyName, manyEndEntityPropertiesWrapper, addTypesFullNameShortName); } break; } }
public Long getLong(String key, Long defValue) { return PropertiesHelper.getLong(map.get(key), defValue); }
public Boolean getBoolean(String key, Boolean defValue) { return PropertiesHelper.getBoolean(map.get(key), defValue); }
public PropertyMap getMap(String key, PropertyMap defValue) { return PropertiesHelper.getMap(map.get(key), defValue); }
public PropertyList getList(String key, PropertyList defValue) { return PropertiesHelper.getList(map.get(key), defValue); }
public Date getDate(String key, Date defValue) { return PropertiesHelper.getDate(map.get(key), defValue); }