Commit 353da38a authored by leberre's avatar leberre

Initial attempt to create a maven structure for sat4j core.

git-svn-id: svn+ssh://svn.forge.ow2.org/svnroot/sat4j/maven/trunk@8 ba638df5-4473-46d1-82f8-c3ae2a17a6e1
parent cd37f877
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry kind="src" path="src/main/java"/>
<classpathentry kind="src" path="src/test/java"/>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/3.8.1"/>
<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
<classpathentry kind="output" path="bin"/>
</classpath>
.settings
bin
.checkstyle
.fbwarnings
.teamtask_meta
sat4j.jardesc
*.sxw
#FindBugs User Preferences
#Fri Mar 23 14:23:38 CET 2007
default_directory=/home/leberre
detectorBadAppletConstructor=BadAppletConstructor|false
detectorBadResultSetAccess=BadResultSetAccess|true
detectorBadSyntaxForRegularExpression=BadSyntaxForRegularExpression|true
detectorBadUseOfReturnValue=BadUseOfReturnValue|true
detectorBadlyOverriddenAdapter=BadlyOverriddenAdapter|true
detectorCheckImmutableAnnotation=CheckImmutableAnnotation|true
detectorCloneIdiom=CloneIdiom|true
detectorComparatorIdiom=ComparatorIdiom|true
detectorConfusedInheritance=ConfusedInheritance|true
detectorConfusionBetweenInheritedAndOuterMethod=ConfusionBetweenInheritedAndOuterMethod|true
detectorDoInsideDoPrivileged=DoInsideDoPrivileged|true
detectorDontCatchIllegalMonitorStateException=DontCatchIllegalMonitorStateException|true
detectorDroppedException=DroppedException|true
detectorDumbMethodInvocations=DumbMethodInvocations|true
detectorDumbMethods=DumbMethods|true
detectorDuplicateBranches=DuplicateBranches|true
detectorEmptyZipFileEntry=EmptyZipFileEntry|true
detectorFindBadCast2=FindBadCast2|true
detectorFindBadForLoop=FindBadForLoop|true
detectorFindCircularDependencies=FindCircularDependencies|false
detectorFindDeadLocalStores=FindDeadLocalStores|true
detectorFindDoubleCheck=FindDoubleCheck|true
detectorFindEmptySynchronizedBlock=FindEmptySynchronizedBlock|true
detectorFindFieldSelfAssignment=FindFieldSelfAssignment|true
detectorFindFinalizeInvocations=FindFinalizeInvocations|true
detectorFindFloatEquality=FindFloatEquality|true
detectorFindHEmismatch=FindHEmismatch|true
detectorFindInconsistentSync2=FindInconsistentSync2|true
detectorFindJSR166LockMonitorenter=FindJSR166LockMonitorenter|true
detectorFindLocalSelfAssignment2=FindLocalSelfAssignment2|true
detectorFindMaskedFields=FindMaskedFields|true
detectorFindMismatchedWaitOrNotify=FindMismatchedWaitOrNotify|true
detectorFindNakedNotify=FindNakedNotify|true
detectorFindNonSerializableStoreIntoSession=FindNonSerializableStoreIntoSession|true
detectorFindNonSerializableValuePassedToWriteObject=FindNonSerializableValuePassedToWriteObject|true
detectorFindNonShortCircuit=FindNonShortCircuit|true
detectorFindNullDeref=FindNullDeref|true
detectorFindOpenStream=FindOpenStream|true
detectorFindPuzzlers=FindPuzzlers|true
detectorFindRefComparison=FindRefComparison|true
detectorFindReturnRef=FindReturnRef|true
detectorFindRunInvocations=FindRunInvocations|true
detectorFindSelfComparison=FindSelfComparison|true
detectorFindSelfComparison2=FindSelfComparison2|true
detectorFindSleepWithLockHeld=FindSleepWithLockHeld|true
detectorFindSpinLoop=FindSpinLoop|true
detectorFindSqlInjection=FindSqlInjection|true
detectorFindTwoLockWait=FindTwoLockWait|true
detectorFindUncalledPrivateMethods=FindUncalledPrivateMethods|true
detectorFindUnconditionalWait=FindUnconditionalWait|true
detectorFindUninitializedGet=FindUninitializedGet|true
detectorFindUnrelatedTypesInGenericContainer=FindUnrelatedTypesInGenericContainer|true
detectorFindUnreleasedLock=FindUnreleasedLock|true
detectorFindUnsyncGet=FindUnsyncGet|true
detectorFindUselessControlFlow=FindUselessControlFlow|true
detectorHugeSharedStringConstants=HugeSharedStringConstants|true
detectorIDivResultCastToDouble=IDivResultCastToDouble|true
detectorIncompatMask=IncompatMask|true
detectorInefficientMemberAccess=InefficientMemberAccess|false
detectorInefficientToArray=InefficientToArray|true
detectorInfiniteLoop=InfiniteLoop|true
detectorInfiniteRecursiveLoop=InfiniteRecursiveLoop|true
detectorInfiniteRecursiveLoop2=InfiniteRecursiveLoop2|false
detectorInheritanceUnsafeGetResource=InheritanceUnsafeGetResource|true
detectorInitializationChain=InitializationChain|true
detectorInstantiateStaticClass=InstantiateStaticClass|true
detectorInvalidJUnitTest=InvalidJUnitTest|true
detectorIteratorIdioms=IteratorIdioms|true
detectorLazyInit=LazyInit|true
detectorLoadOfKnownNullValue=LoadOfKnownNullValue|true
detectorMethodReturnCheck=MethodReturnCheck|true
detectorMultithreadedInstanceAccess=MultithreadedInstanceAccess|true
detectorMutableLock=MutableLock|true
detectorMutableStaticFields=MutableStaticFields|true
detectorNaming=Naming|true
detectorNumberConstructor=NumberConstructor|true
detectorPreferZeroLengthArrays=PreferZeroLengthArrays|true
detectorPublicSemaphores=PublicSemaphores|false
detectorQuestionableBooleanAssignment=QuestionableBooleanAssignment|true
detectorReadReturnShouldBeChecked=ReadReturnShouldBeChecked|true
detectorRedundantInterfaces=RedundantInterfaces|true
detectorRuntimeExceptionCapture=RuntimeExceptionCapture|true
detectorSerializableIdiom=SerializableIdiom|true
detectorStartInConstructor=StartInConstructor|true
detectorStringConcatenation=StringConcatenation|true
detectorSuperfluousInstanceOf=SuperfluousInstanceOf|true
detectorSuspiciousThreadInterrupted=SuspiciousThreadInterrupted|true
detectorSwitchFallthrough=SwitchFallthrough|true
detectorURLProblems=URLProblems|true
detectorUncallableMethodOfAnonymousClass=UncallableMethodOfAnonymousClass|true
detectorUnnecessaryMath=UnnecessaryMath|true
detectorUnreadFields=UnreadFields|true
detectorUseObjectEquals=UseObjectEquals|false
detectorUselessSubclassMethod=UselessSubclassMethod|false
detectorVarArgsProblems=VarArgsProblems|true
detectorVolatileUsage=VolatileUsage|true
detectorWaitInLoop=WaitInLoop|true
detectorWrongMapIterator=WrongMapIterator|true
detectorXMLFactoryBypass=XMLFactoryBypass|true
detector_threshold=2
filter_settings=Medium|STYLE,MALICIOUS_CODE,BAD_PRACTICE,CORRECTNESS,I18N,PERFORMANCE,MT_CORRECTNESS|false
filter_settings_neg=|
<?xml version="1.0" encoding="UTF-8"?>
<pmd><useProjectRuleSet>false</useProjectRuleSet><rules><rule><name>AbstractClassWithoutAbstractMethod</name><ruleset>Design Rules</ruleset></rule><rule><name>AbstractNaming</name><ruleset>Naming Rules</ruleset></rule><rule><name>AccessorClassGeneration</name><ruleset>Design Rules</ruleset></rule><rule><name>AppendCharacterWithChar</name><ruleset>String and StringBuffer Rules</ruleset></rule><rule><name>ArrayIsStoredDirectly</name><ruleset>Security Code Guidelines</ruleset></rule><rule><name>AssignmentInOperand</name><ruleset>Controversial Rules</ruleset></rule><rule><name>AssignmentToNonFinalStatic</name><ruleset>Design Rules</ruleset></rule><rule><name>AtLeastOneConstructor</name><ruleset>Controversial Rules</ruleset></rule><rule><name>AvoidArrayLoops</name><ruleset>Optimization Rules</ruleset></rule><rule><name>AvoidAssertAsIdentifier</name><ruleset>Migration Rules</ruleset></rule><rule><name>AvoidCallingFinalize</name><ruleset>Finalizer Rules</ruleset></rule><rule><name>AvoidCatchingNPE</name><ruleset>Strict Exception Rules</ruleset></rule><rule><name>AvoidCatchingThrowable</name><ruleset>Strict Exception Rules</ruleset></rule><rule><name>AvoidConstantsInterface</name><ruleset>Design Rules</ruleset></rule><rule><name>AvoidDecimalLiteralsInBigDecimalConstructor</name><ruleset>Basic Rules</ruleset></rule><rule><name>AvoidDeeplyNestedIfStmts</name><ruleset>Design Rules</ruleset></rule><rule><name>AvoidDollarSigns</name><ruleset>Naming Rules</ruleset></rule><rule><name>AvoidDuplicateLiterals</name><ruleset>String and StringBuffer Rules</ruleset></rule><rule><name>AvoidEnumAsIdentifier</name><ruleset>Migration Rules</ruleset></rule><rule><name>AvoidFieldNameMatchingMethodName</name><ruleset>Naming Rules</ruleset></rule><rule><name>AvoidFieldNameMatchingTypeName</name><ruleset>Naming Rules</ruleset></rule><rule><name>AvoidInstanceofChecksInCatchClause</name><ruleset>Design Rules</ruleset></rule><rule><name>AvoidInstantiatingObjectsInLoops</name><ruleset>Optimization Rules</ruleset></rule><rule><name>AvoidNonConstructorMethodsWithClassName</name><ruleset>Naming Rules</ruleset></rule><rule><name>AvoidPrintStackTrace</name><ruleset>Java Logging Rules</ruleset></rule><rule><name>AvoidProtectedFieldInFinalClass</name><ruleset>Design Rules</ruleset></rule><rule><name>AvoidReassigningParameters</name><ruleset>Design Rules</ruleset></rule><rule><name>AvoidRethrowingException</name><ruleset>Strict Exception Rules</ruleset></rule><rule><name>AvoidSynchronizedAtMethodLevel</name><ruleset>Design Rules</ruleset></rule><rule><name>AvoidThreadGroup</name><ruleset>Basic Rules</ruleset></rule><rule><name>AvoidThrowingNullPointerException</name><ruleset>Strict Exception Rules</ruleset></rule><rule><name>AvoidThrowingRawExceptionTypes</name><ruleset>Strict Exception Rules</ruleset></rule><rule><name>AvoidUsingOctalValues</name><ruleset>Basic Rules</ruleset></rule><rule><name>BadComparison</name><ruleset>Design Rules</ruleset></rule><rule><name>BeanMembersShouldSerialize</name><ruleset>JavaBean Rules</ruleset></rule><rule><name>BigIntegerInstantiation</name><ruleset>Basic Rules</ruleset></rule><rule><name>BooleanInstantiation</name><ruleset>Basic Rules</ruleset></rule><rule><name>BooleanInversion</name><ruleset>Controversial Rules</ruleset></rule><rule><name>BrokenNullCheck</name><ruleset>Basic Rules</ruleset></rule><rule><name>CallSuperInConstructor</name><ruleset>Controversial Rules</ruleset></rule><rule><name>ClassCastExceptionWithToArray</name><ruleset>Basic Rules</ruleset></rule><rule><name>ClassNamingConventions</name><ruleset>Naming Rules</ruleset></rule><rule><name>CloneMethodMustImplementCloneable</name><ruleset>Clone Implementation Rules</ruleset></rule><rule><name>CloneMethodMustImplementCloneable</name><ruleset>Type Resolution Rules</ruleset></rule><rule><name>CloneThrowsCloneNotSupportedException</name><ruleset>Clone Implementation Rules</ruleset></rule><rule><name>CloseResource</name><ruleset>Design Rules</ruleset></rule><rule><name>CollapsibleIfStatements</name><ruleset>Basic Rules</ruleset></rule><rule><name>CompareObjectsWithEquals</name><ruleset>Design Rules</ruleset></rule><rule><name>ConfusingTernary</name><ruleset>Design Rules</ruleset></rule><rule><name>ConsecutiveLiteralAppends</name><ruleset>String and StringBuffer Rules</ruleset></rule><rule><name>ConstructorCallsOverridableMethod</name><ruleset>Design Rules</ruleset></rule><rule><name>CouplingBetweenObjects</name><ruleset>Coupling Rules</ruleset></rule><rule><name>CyclomaticComplexity</name><ruleset>Code Size Rules</ruleset></rule><rule><name>DataflowAnomalyAnalysis</name><ruleset>Controversial Rules</ruleset></rule><rule><name>DefaultLabelNotLastInSwitchStmt</name><ruleset>Design Rules</ruleset></rule><rule><name>DefaultPackage</name><ruleset>Controversial Rules</ruleset></rule><rule><name>DontImportJavaLang</name><ruleset>Import Statement Rules</ruleset></rule><rule><name>DontImportSun</name><ruleset>Controversial Rules</ruleset></rule><rule><name>DoubleCheckedLocking</name><ruleset>Basic Rules</ruleset></rule><rule><name>DuplicateImports</name><ruleset>Import Statement Rules</ruleset></rule><rule><name>EmptyCatchBlock</name><ruleset>Basic Rules</ruleset></rule><rule><name>EmptyFinalizer</name><ruleset>Finalizer Rules</ruleset></rule><rule><name>EmptyFinallyBlock</name><ruleset>Basic Rules</ruleset></rule><rule><name>EmptyIfStmt</name><ruleset>Basic Rules</ruleset></rule><rule><name>EmptyStatementNotInLoop</name><ruleset>Basic Rules</ruleset></rule><rule><name>EmptyStaticInitializer</name><ruleset>Basic Rules</ruleset></rule><rule><name>EmptySwitchStatements</name><ruleset>Basic Rules</ruleset></rule><rule><name>EmptySynchronizedBlock</name><ruleset>Basic Rules</ruleset></rule><rule><name>EmptyTryBlock</name><ruleset>Basic Rules</ruleset></rule><rule><name>EmptyWhileStmt</name><ruleset>Basic Rules</ruleset></rule><rule><name>EqualsNull</name><ruleset>Design Rules</ruleset></rule><rule><name>ExceptionAsFlowControl</name><ruleset>Strict Exception Rules</ruleset></rule><rule><name>ExcessiveClassLength</name><ruleset>Code Size Rules</ruleset></rule><rule><name>ExcessiveImports</name><ruleset>Coupling Rules</ruleset></rule><rule><name>ExcessiveMethodLength</name><ruleset>Code Size Rules</ruleset></rule><rule><name>ExcessiveParameterList</name><ruleset>Code Size Rules</ruleset></rule><rule><name>ExcessivePublicCount</name><ruleset>Code Size Rules</ruleset></rule><rule><name>FinalFieldCouldBeStatic</name><ruleset>Design Rules</ruleset></rule><rule><name>FinalizeDoesNotCallSuperFinalize</name><ruleset>Finalizer Rules</ruleset></rule><rule><name>FinalizeOnlyCallsSuperFinalize</name><ruleset>Finalizer Rules</ruleset></rule><rule><name>FinalizeOverloaded</name><ruleset>Finalizer Rules</ruleset></rule><rule><name>FinalizeShouldBeProtected</name><ruleset>Finalizer Rules</ruleset></rule><rule><name>ForLoopShouldBeWhileLoop</name><ruleset>Basic Rules</ruleset></rule><rule><name>ForLoopsMustUseBraces</name><ruleset>Braces Rules</ruleset></rule><rule><name>IdempotentOperations</name><ruleset>Design Rules</ruleset></rule><rule><name>IfElseStmtsMustUseBraces</name><ruleset>Braces Rules</ruleset></rule><rule><name>IfStmtsMustUseBraces</name><ruleset>Braces Rules</ruleset></rule><rule><name>ImmutableField</name><ruleset>Design Rules</ruleset></rule><rule><name>ImportFromSamePackage</name><ruleset>Import Statement Rules</ruleset></rule><rule><name>InefficientEmptyStringCheck</name><ruleset>String and StringBuffer Rules</ruleset></rule><rule><name>InefficientStringBuffering</name><ruleset>String and StringBuffer Rules</ruleset></rule><rule><name>InstantiationToGetClass</name><ruleset>Design Rules</ruleset></rule><rule><name>InsufficientStringBufferDeclaration</name><ruleset>String and StringBuffer Rules</ruleset></rule><rule><name>IntegerInstantiation</name><ruleset>Migration Rules</ruleset></rule><rule><name>JUnitAssertionsShouldIncludeMessage</name><ruleset>JUnit Rules</ruleset></rule><rule><name>JUnitSpelling</name><ruleset>JUnit Rules</ruleset></rule><rule><name>JUnitStaticSuite</name><ruleset>JUnit Rules</ruleset></rule><rule><name>JUnitTestsShouldIncludeAssert</name><ruleset>JUnit Rules</ruleset></rule><rule><name>JumbledIncrementer</name><ruleset>Basic Rules</ruleset></rule><rule><name>LocalVariableCouldBeFinal</name><ruleset>Optimization Rules</ruleset></rule><rule><name>LoggerIsNotStaticFinal</name><ruleset>Java Logging Rules</ruleset></rule><rule><name>LongVariable</name><ruleset>Naming Rules</ruleset></rule><rule><name>LooseCoupling</name><ruleset>Type Resolution Rules</ruleset></rule><rule><name>LooseCoupling</name><ruleset>Coupling Rules</ruleset></rule><rule><name>MethodArgumentCouldBeFinal</name><ruleset>Optimization Rules</ruleset></rule><rule><name>MethodNamingConventions</name><ruleset>Naming Rules</ruleset></rule><rule><name>MethodReturnsInternalArray</name><ruleset>Security Code Guidelines</ruleset></rule><rule><name>MethodWithSameNameAsEnclosingClass</name><ruleset>Naming Rules</ruleset></rule><rule><name>MisleadingVariableName</name><ruleset>Naming Rules</ruleset></rule><rule><name>MisplacedNullCheck</name><ruleset>Basic Rules</ruleset></rule><rule><name>MissingBreakInSwitch</name><ruleset>Design Rules</ruleset></rule><rule><name>MissingSerialVersionUID</name><ruleset>JavaBean Rules</ruleset></rule><rule><name>MissingStaticMethodInNonInstantiatableClass</name><ruleset>Design Rules</ruleset></rule><rule><name>MoreThanOneLogger</name><ruleset>Java Logging Rules</ruleset></rule><rule><name>NPathComplexity</name><ruleset>Code Size Rules</ruleset></rule><rule><name>NcssConstructorCount</name><ruleset>Code Size Rules</ruleset></rule><rule><name>NcssMethodCount</name><ruleset>Code Size Rules</ruleset></rule><rule><name>NcssTypeCount</name><ruleset>Code Size Rules</ruleset></rule><rule><name>NoPackage</name><ruleset>Naming Rules</ruleset></rule><rule><name>NonCaseLabelInSwitchStatement</name><ruleset>Design Rules</ruleset></rule><rule><name>NonStaticInitializer</name><ruleset>Design Rules</ruleset></rule><rule><name>NonThreadSafeSingleton</name><ruleset>Design Rules</ruleset></rule><rule><name>NullAssignment</name><ruleset>Controversial Rules</ruleset></rule><rule><name>OnlyOneReturn</name><ruleset>Controversial Rules</ruleset></rule><rule><name>OptimizableToArrayCall</name><ruleset>Design Rules</ruleset></rule><rule><name>OverrideBothEqualsAndHashcode</name><ruleset>Basic Rules</ruleset></rule><rule><name>PackageCase</name><ruleset>Naming Rules</ruleset></rule><rule><name>PositionLiteralsFirstInComparisons</name><ruleset>Design Rules</ruleset></rule><rule><name>PreserveStackTrace</name><ruleset>Design Rules</ruleset></rule><rule><name>ProperCloneImplementation</name><ruleset>Clone Implementation Rules</ruleset></rule><rule><name>ProperLogger</name><ruleset>Jakarta Commons Logging Rules</ruleset></rule><rule><name>ReplaceEnumerationWithIterator</name><ruleset>Migration Rules</ruleset></rule><rule><name>ReplaceHashtableWithMap</name><ruleset>Migration Rules</ruleset></rule><rule><name>ReplaceVectorWithList</name><ruleset>Migration Rules</ruleset></rule><rule><name>ReturnFromFinallyBlock</name><ruleset>Basic Rules</ruleset></rule><rule><name>ShortMethodName</name><ruleset>Naming Rules</ruleset></rule><rule><name>ShortVariable</name><ruleset>Naming Rules</ruleset></rule><rule><name>SignatureDeclareThrowsException</name><ruleset>Strict Exception Rules</ruleset></rule><rule><name>SimpleDateFormatNeedsLocale</name><ruleset>Design Rules</ruleset></rule><rule><name>SimplifyBooleanAssertion</name><ruleset>JUnit Rules</ruleset></rule><rule><name>SimplifyBooleanExpressions</name><ruleset>Design Rules</ruleset></rule><rule><name>SimplifyBooleanReturns</name><ruleset>Design Rules</ruleset></rule><rule><name>SimplifyConditional</name><ruleset>Design Rules</ruleset></rule><rule><name>SimplifyStartsWith</name><ruleset>Optimization Rules</ruleset></rule><rule><name>SingularField</name><ruleset>Controversial Rules</ruleset></rule><rule><name>StringBufferInstantiationWithChar</name><ruleset>String and StringBuffer Rules</ruleset></rule><rule><name>StringInstantiation</name><ruleset>String and StringBuffer Rules</ruleset></rule><rule><name>StringToString</name><ruleset>String and StringBuffer Rules</ruleset></rule><rule><name>SuspiciousConstantFieldName</name><ruleset>Naming Rules</ruleset></rule><rule><name>SuspiciousEqualsMethodName</name><ruleset>Naming Rules</ruleset></rule><rule><name>SuspiciousHashcodeMethodName</name><ruleset>Naming Rules</ruleset></rule><rule><name>SuspiciousOctalEscape</name><ruleset>Controversial Rules</ruleset></rule><rule><name>SwitchDensity</name><ruleset>Design Rules</ruleset></rule><rule><name>SwitchStmtsShouldHaveDefault</name><ruleset>Design Rules</ruleset></rule><rule><name>SystemPrintln</name><ruleset>Java Logging Rules</ruleset></rule><rule><name>TestClassWithoutTestCases</name><ruleset>JUnit Rules</ruleset></rule><rule><name>TooManyFields</name><ruleset>Code Size Rules</ruleset></rule><rule><name>UncommentedEmptyConstructor</name><ruleset>Design Rules</ruleset></rule><rule><name>UncommentedEmptyMethod</name><ruleset>Design Rules</ruleset></rule><rule><name>UnconditionalIfStatement</name><ruleset>Basic Rules</ruleset></rule><rule><name>UnnecessaryBooleanAssertion</name><ruleset>JUnit Rules</ruleset></rule><rule><name>UnnecessaryCaseChange</name><ruleset>String and StringBuffer Rules</ruleset></rule><rule><name>UnnecessaryConstructor</name><ruleset>Controversial Rules</ruleset></rule><rule><name>UnnecessaryConversionTemporary</name><ruleset>Basic Rules</ruleset></rule><rule><name>UnnecessaryFinalModifier</name><ruleset>Basic Rules</ruleset></rule><rule><name>UnnecessaryLocalBeforeReturn</name><ruleset>Design Rules</ruleset></rule><rule><name>UnnecessaryParentheses</name><ruleset>Controversial Rules</ruleset></rule><rule><name>UnnecessaryReturn</name><ruleset>Basic Rules</ruleset></rule><rule><name>UnnecessaryWrapperObjectCreation</name><ruleset>Optimization Rules</ruleset></rule><rule><name>UnsynchronizedStaticDateFormatter</name><ruleset>Design Rules</ruleset></rule><rule><name>UnusedFormalParameter</name><ruleset>Unused Code Rules</ruleset></rule><rule><name>UnusedImports</name><ruleset>Import Statement Rules</ruleset></rule><rule><name>UnusedLocalVariable</name><ruleset>Unused Code Rules</ruleset></rule><rule><name>UnusedModifier</name><ruleset>Controversial Rules</ruleset></rule><rule><name>UnusedNullCheckInEquals</name><ruleset>Basic Rules</ruleset></rule><rule><name>UnusedPrivateField</name><ruleset>Unused Code Rules</ruleset></rule><rule><name>UnusedPrivateMethod</name><ruleset>Unused Code Rules</ruleset></rule><rule><name>UseArrayListInsteadOfVector</name><ruleset>Optimization Rules</ruleset></rule><rule><name>UseArraysAsList</name><ruleset>Optimization Rules</ruleset></rule><rule><name>UseAssertEqualsInsteadOfAssertTrue</name><ruleset>JUnit Rules</ruleset></rule><rule><name>UseAssertNullInsteadOfAssertTrue</name><ruleset>JUnit Rules</ruleset></rule><rule><name>UseAssertSameInsteadOfAssertTrue</name><ruleset>JUnit Rules</ruleset></rule><rule><name>UseCollectionIsEmpty</name><ruleset>Design Rules</ruleset></rule><rule><name>UseCorrectExceptionLogging</name><ruleset>Jakarta Commons Logging Rules</ruleset></rule><rule><name>UseIndexOfChar</name><ruleset>String and StringBuffer Rules</ruleset></rule><rule><name>UseLocaleWithCaseConversions</name><ruleset>Design Rules</ruleset></rule><rule><name>UseNotifyAllInsteadOfNotify</name><ruleset>Design Rules</ruleset></rule><rule><name>UseProperClassLoader</name><ruleset>J2EE Rules</ruleset></rule><rule><name>UseSingleton</name><ruleset>Design Rules</ruleset></rule><rule><name>UseStringBufferForStringAppends</name><ruleset>Optimization Rules</ruleset></rule><rule><name>UseStringBufferLength</name><ruleset>String and StringBuffer Rules</ruleset></rule><rule><name>UselessOperationOnImmutable</name><ruleset>Basic Rules</ruleset></rule><rule><name>UselessOverridingMethod</name><ruleset>Basic Rules</ruleset></rule><rule><name>UselessStringValueOf</name><ruleset>String and StringBuffer Rules</ruleset></rule><rule><name>VariableNamingConventions</name><ruleset>Naming Rules</ruleset></rule><rule><name>WhileLoopsMustUseBraces</name><ruleset>Braces Rules</ruleset></rule></rules><includeDerivedFiles>false</includeDerivedFiles></pmd>
\ No newline at end of file
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
<name>org.sat4j.core</name>
<comment></comment>
<projects>
</projects>
<buildSpec>
<buildCommand>
<name>org.eclipse.jdt.core.javabuilder</name>
<arguments>
</arguments>
</buildCommand>
<buildCommand>
<name>com.omondo.uml.enterprise.Builder</name>
<arguments>
</arguments>
</buildCommand>
<buildCommand>
<name>net.sourceforge.metrics.builder</name>
<arguments>
</arguments>
</buildCommand>
<buildCommand>
<name>org.eclipse.pde.ManifestBuilder</name>
<arguments>
</arguments>
</buildCommand>
<buildCommand>
<name>org.eclipse.pde.SchemaBuilder</name>
<arguments>
</arguments>
</buildCommand>
</buildSpec>
<natures>
<nature>org.eclipse.jdt.core.javanature</nature>
<nature>net.sourceforge.metrics.nature</nature>
<nature>org.eclipse.pde.PluginNature</nature>
</natures>
</projectDescription>
Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: %bundleName
Bundle-SymbolicName: org.sat4j.core
Bundle-Version: 9.9.9.token
Export-Package: org.sat4j,
org.sat4j.core,
org.sat4j.minisat,
org.sat4j.minisat.constraints,
org.sat4j.minisat.constraints.card,
org.sat4j.minisat.constraints.cnf,
org.sat4j.minisat.core,
org.sat4j.minisat.learning,
org.sat4j.minisat.orders,
org.sat4j.minisat.restarts,
org.sat4j.minisat.uip,
org.sat4j.opt,
org.sat4j.reader,
org.sat4j.specs,
org.sat4j.tools
Bundle-Vendor: %providerName
Bundle-Localization: plugin
Built-By: Daniel Le Berre
Main-Class: org.sat4j.BasicLauncher
Specification-Title: SAT4J
Specification-Version: NA
Specification-Vendor: Daniel Le Berre
Implementation-Title: SAT4J
Implementation-Version: 2.0
Implementation-Vendor: CRIL CNRS UMR 8188 - Universite d'Artois
Bundle-RequiredExecutionEnvironment: J2SE-1.4
source.. = src/
bin.includes = META-INF/,\
.,\
plugin.properties,\
src/main/resources/about.html
###############################################################################
# SAT4J: a SATisfiability library for Java Copyright (C) 2004-2008 Daniel Le Berre
#
# All rights reserved. This program and the accompanying materials
# are made available under the terms of the Eclipse Public License v1.0
# which accompanies this distribution, and is available at
# http://www.eclipse.org/legal/epl-v10.html
#
# Alternatively, the contents of this file may be used under the terms of
# either the GNU Lesser General Public License Version 2.1 or later (the
# "LGPL"), in which case the provisions of the LGPL are applicable instead
# of those above. If you wish to allow use of your version of this file only
# under the terms of the LGPL, and not to allow others to use your version of
# this file under the terms of the EPL, indicate your decision by deleting
# the provisions above and replace them with the notice and other provisions
# required by the LGPL. If you do not delete the provisions above, a recipient
# may use your version of this file under the terms of the EPL or the LGPL.
#
# Based on the original MiniSat specification from:
#
# An extensible SAT solver. Niklas Een and Niklas Sorensson. Proceedings of the
# Sixth International Conference on Theory and Applications of Satisfiability
# Testing, LNCS 2919, pp 502-518, 2003.
#
# See www.minisat.se for the original solver in C++.
#
###############################################################################
bundleName = SAT4J Core
providerName = CRIL CNRS UMR 8188 - Universite d'Artois
<?xml version="1.0" encoding="UTF-8"?><project>
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.sat4j</groupId>
<artifactId>org.sat4j.pom</artifactId>
<version>2.0.0</version>
</parent>
<artifactId>org.sat4j.core</artifactId>
<name>SAT4J core</name>
</project>
/*******************************************************************************
* SAT4J: a SATisfiability library for Java Copyright (C) 2004-2008 Daniel Le Berre
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU Lesser General Public License Version 2.1 or later (the
* "LGPL"), in which case the provisions of the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of the LGPL, and not to allow others to use your version of
* this file under the terms of the EPL, indicate your decision by deleting
* the provisions above and replace them with the notice and other provisions
* required by the LGPL. If you do not delete the provisions above, a recipient
* may use your version of this file under the terms of the EPL or the LGPL.
*
* Based on the original MiniSat specification from:
*
* An extensible SAT solver. Niklas Een and Niklas Sorensson. Proceedings of the
* Sixth International Conference on Theory and Applications of Satisfiability
* Testing, LNCS 2919, pp 502-518, 2003.
*
* See www.minisat.se for the original solver in C++.
*
*******************************************************************************/
package org.sat4j;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.PrintWriter;
import java.io.Serializable;
import java.net.URL;
import java.util.Properties;
import org.sat4j.core.ASolverFactory;
import org.sat4j.reader.ParseFormatException;
import org.sat4j.reader.Reader;
import org.sat4j.specs.ContradictionException;
import org.sat4j.specs.IProblem;
import org.sat4j.specs.ISolver;
import org.sat4j.specs.TimeoutException;
/**
* That class is used by launchers used to solve decision problems, i.e.
* problems with YES/NO/UNKNOWN answers.
*
* @author leberre
*
*/
public abstract class AbstractLauncher implements Serializable {
/**
*
*/
private static final long serialVersionUID = 1L;
public static final String SOLUTION_PREFIX = "v "; //$NON-NLS-1$
public static final String ANSWER_PREFIX = "s "; //$NON-NLS-1$
public static final String COMMENT_PREFIX = "c "; //$NON-NLS-1$
private long beginTime;
private ExitCode exitCode = ExitCode.UNKNOWN;
protected Reader reader;
private transient PrintWriter out = new PrintWriter(System.out, true);
protected transient Thread shutdownHook = new Thread() {
@Override
public void run() {
displayResult();
}
};
protected ISolver solver;
private boolean silent = false;
protected AbstractLauncher() {
Runtime.getRuntime().addShutdownHook(shutdownHook);
}
protected void displayResult() {
if (solver != null) {
double wallclocktime = (System.currentTimeMillis() - beginTime) / 1000.0;
solver.printStat(out, COMMENT_PREFIX);
out.println(ANSWER_PREFIX + exitCode);
if (exitCode == ExitCode.SATISFIABLE) {
int[] model = solver.model();
out.print(SOLUTION_PREFIX);
reader.decode(model, out);
out.println();
}
log("Total wall clock time (in seconds) : " + wallclocktime); //$NON-NLS-1$
}
}
public abstract void usage();
/**
* @throws IOException
*/
protected final void displayHeader() {
displayLicense();
URL url = AbstractLauncher.class.getResource("/sat4j.version"); //$NON-NLS-1$
if (url == null) {
log("no version file found!!!"); //$NON-NLS-1$
} else {
BufferedReader in = null;
try {
in = new BufferedReader(new InputStreamReader(url
.openStream()));
log("version " + in.readLine()); //$NON-NLS-1$
} catch (IOException e) {
log("c ERROR: "+e.getMessage());
} finally {
if (in!=null) {
try {
in.close();
} catch (IOException e) {
log("c ERROR: "+e.getMessage());
}
}
}
}
Properties prop = System.getProperties();
String[] infoskeys = {
"sun.arch.data.model", "java.version", "os.name", "os.version", "os.arch" }; //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$//$NON-NLS-5$
for (String key : infoskeys) {
log(key + "\t" + prop.getProperty(key)); //$NON-NLS-1$
}
Runtime runtime = Runtime.getRuntime();
log("Free memory " + runtime.freeMemory()); //$NON-NLS-1$
log("Max memory " + runtime.maxMemory()); //$NON-NLS-1$
log("Total memory " + runtime.totalMemory()); //$NON-NLS-1$
log("Number of processors " + runtime.availableProcessors()); //$NON-NLS-1$
}
public void displayLicense() {
log("SAT4J: a SATisfiability library for Java (c) 2004-2008 Daniel Le Berre"); //$NON-NLS-1$
log("This is free software under the dual EPL/GNU LGPL licenses."); //$NON-NLS-1$
log("See www.sat4j.org for details."); //$NON-NLS-1$
}
/**
* Reads a problem file from the command line.
*
* @param problemname
* the fully qualified name of the problem.
* @return a reference to the problem to solve
* @throws FileNotFoundException
* if the file is not found
* @throws ParseFormatException
* if the problem is not expressed using the right format
* @throws IOException
* for other IO problems
* @throws ContradictionException
* if the problem is found trivially unsat
*/
protected IProblem readProblem(String problemname)
throws FileNotFoundException, ParseFormatException, IOException,
ContradictionException {
log("solving " + problemname); //$NON-NLS-1$
log("reading problem ... "); //$NON-NLS-1$
reader = createReader(solver, problemname);
IProblem problem = reader.parseInstance(problemname);
log("... done. Wall clock time " //$NON-NLS-1$
+ (System.currentTimeMillis() - beginTime) / 1000.0 + "s."); //$NON-NLS-1$
log("#vars " + problem.nVars()); //$NON-NLS-1$
log("#constraints " + problem.nConstraints()); //$NON-NLS-1$
problem.printInfos(out,COMMENT_PREFIX);
return problem;
}
protected abstract Reader createReader(ISolver solver, String problemname);
public void run(String[] args) {
try {
displayHeader();
solver = configureSolver(args);
if (solver == null)
return;
String instanceName = getInstanceName(args);
beginTime = System.currentTimeMillis();
IProblem problem = readProblem(instanceName);
try {
solve(problem);
} catch (TimeoutException e) {
log("timeout"); //$NON-NLS-1$
}
} catch (FileNotFoundException e) {
log("FATAL");
e.printStackTrace();
} catch (IOException e) {
log("FATAL");
e.printStackTrace();
} catch (ContradictionException e) {
exitCode = ExitCode.UNSATISFIABLE;
log("(trivial inconsistency)"); //$NON-NLS-1$
} catch (ParseFormatException e) {
log("FATAL");
e.printStackTrace();
}
}
protected abstract String getInstanceName(String[] args);
protected abstract ISolver configureSolver(String[] args);
/**
* Display messages as comments on STDOUT
*
* @param message
*/
protected void log(String message) {
if (!silent)
out.println(COMMENT_PREFIX + message);
}
protected void solve(IProblem problem) throws TimeoutException {
exitCode = problem.isSatisfiable() ? ExitCode.SATISFIABLE
: ExitCode.UNSATISFIABLE;
}
/**
* Change the value of the exit code in the Launcher
*
* @param exitCode
* the new ExitCode
*/
public final void setExitCode(ExitCode exitCode) {
this.exitCode = exitCode;
}
/**
* Get the value of the ExitCode
*
* @return the current value of the Exitcode
*/
public final ExitCode getExitCode() {
return exitCode;
}
/**
* Obtaining the current time spent since the beginning of the solving
* process.
*
* @return the time signature at the beginning of the run() method.
*/
public final long getBeginTime() {
return beginTime;
}
/**
*
* @return the reader used to parse the instance
*/
public final Reader getReader() {
return reader;
}
/**
* To change the output stream on which statistics are displayed. By
* default, the solver displays everything on System.out.
*
* @param out
*/
public void setLogWriter(PrintWriter out) {
this.out = out;
}
public PrintWriter getLogWriter() {
return out;
}
protected void setSilent(boolean b) {
silent = b;
}
private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {
stream.defaultReadObject();
out = new PrintWriter(System.out, true);
shutdownHook = new Thread() {
@Override
public void run() {
displayResult();
}
};
}
protected <T extends ISolver> void showAvailableSolvers(ASolverFactory<T> afactory) {
if (afactory != null) {
log("Available solvers: "); //$NON-NLS-1$
String[] names = afactory.solverNames();
for (int i = 0; i < names.length; i++) {
log(names[i]);
}
}
}
}
/*******************************************************************************
* SAT4J: a SATisfiability library for Java Copyright (C) 2004-2008 Daniel Le Berre
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU Lesser General Public License Version 2.1 or later (the
* "LGPL"), in which case the provisions of the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of the LGPL, and not to allow others to use your version of
* this file under the terms of the EPL, indicate your decision by deleting
* the provisions above and replace them with the notice and other provisions
* required by the LGPL. If you do not delete the provisions above, a recipient
* may use your version of this file under the terms of the EPL or the LGPL.
*
* Based on the original MiniSat specification from:
*
* An extensible SAT solver. Niklas Een and Niklas Sorensson. Proceedings of the
* Sixth International Conference on Theory and Applications of Satisfiability
* Testing, LNCS 2919, pp 502-518, 2003.
*
* See www.minisat.se for the original solver in C++.
*
*******************************************************************************/
package org.sat4j;
import java.io.PrintWriter;
import org.sat4j.specs.ContradictionException;
import org.sat4j.specs.IOptimizationProblem;
import org.sat4j.specs.IProblem;
import org.sat4j.specs.TimeoutException;
/**
* This class is intended to be used by launchers to solve optimization
* problems, i.e. problems for which a loop is needed to find the optimal