diff --git a/sensors/sensorhub-system-lane/src/main/java/com/botts/impl/system/lane/WebIdOutput.java b/sensors/sensorhub-system-lane/src/main/java/com/botts/impl/system/lane/WebIdOutput.java new file mode 100644 index 00000000..9d4c31de --- /dev/null +++ b/sensors/sensorhub-system-lane/src/main/java/com/botts/impl/system/lane/WebIdOutput.java @@ -0,0 +1,41 @@ +package com.botts.impl.system.lane; + +import net.opengis.swe.v20.DataBlock; +import net.opengis.swe.v20.DataComponent; +import net.opengis.swe.v20.DataEncoding; +import org.sensorhub.api.data.DataEvent; +import org.sensorhub.impl.sensor.VarRateSensorOutput; +import org.sensorhub.impl.utils.rad.RADHelper; +import org.sensorhub.impl.utils.rad.model.WebIdAnalysis; +import org.vast.data.TextEncodingImpl; + +public class WebIdOutput extends VarRateSensorOutput { + + public static final String NAME = "webIdAnalysis"; + + DataComponent recordStruct; + DataEncoding recordEncoding; + + public WebIdOutput(LaneSystem parentSensor) { + super(NAME, parentSensor, 0); + + recordStruct = new RADHelper().createWebIdRecord(); + recordEncoding = new TextEncodingImpl(); + } + + public void publishData(WebIdAnalysis analysis) { + DataBlock dataBlock = WebIdAnalysis.fromWebIdAnalysis(analysis); + eventHandler.publish(new DataEvent(analysis.getSampleTime().toEpochMilli(), WebIdOutput.this, dataBlock)); + } + + @Override + public DataComponent getRecordDescription() { + return recordStruct; + } + + @Override + public DataEncoding getRecommendedEncoding() { + return recordEncoding; + } + +} diff --git a/sensors/sensorhub-utils-rad/src/main/java/org/sensorhub/impl/utils/rad/RADHelper.java b/sensors/sensorhub-utils-rad/src/main/java/org/sensorhub/impl/utils/rad/RADHelper.java index 1b0f42fd..7dd7195f 100644 --- a/sensors/sensorhub-utils-rad/src/main/java/org/sensorhub/impl/utils/rad/RADHelper.java +++ b/sensors/sensorhub-utils-rad/src/main/java/org/sensorhub/impl/utils/rad/RADHelper.java @@ -383,6 +383,32 @@ public Text createVideoPath() { .build(); } + public Count createWebIdObsIdsCount() { + return createCount() + .label("Web ID Obs IDs Count") + .name("webIdObsIdsCount") + .description("Count of the number of web ID observations associated with this occupancy") + .definition(getRadUri("WebIdObsIdsCount")) + .id("webIdObsIdsCount") + .build(); + } + + public DataArray createWebIdObsIdsArray(){ + return createArray() + .name("webIdObsIds") + .label("Web ID Obs IDs") + .description("List of web ID observation IDs associated with this occupancy") + .definition(getRadUri("WebIdObsIdsArray")) + .withVariableSize("webIdObsIdsCount") + .withElement("webIdObsId", createText() + .name("webIdObsId") + .label("Web ID Obs ID") + .description("ID of the Web ID Observation") + .definition(getRadUri("WebIdObsId")) + .build()) + .build(); + } + public Quantity createBackgroundSigma(){ return createQuantity() .name("backgroundSigma") @@ -1174,4 +1200,91 @@ public DataRecord createCountStatistics() { .build(); } + // Web ID + + public DataRecord createWebIdRecord() { + return createRecord() + .name("webIdAnalysis") + .label("Web ID Analysis") + .definition(getRadUri("WebIDAnalysis")) + .addField("sampleTime", createTime() + .asPhenomenonTimeIsoUTC() + .label("Sample Time") + .definition(SWEHelper.getPropertyUri("SampleTime")) + .build()) + .addField("occupancyObsId", createText() + .label("Occupancy Observation ID") + .definition(SWEHelper.getPropertyUri("OccupancyObsID")) + .build()) + .addField("isotopesCount", createCount() + .label("Isotopes Count") + .id("isotopesCount") + .definition(SWEHelper.getPropertyUri("IsotopesCount")) + .build()) + .addField("isotopes", createArray() + .withVariableSize("isotopesCount") + .definition(SWEHelper.getPropertyUri("Isotopes")) + .withElement("isotope", createRecord() + .addField("name", createText() + .label("Isotope Name") + .definition(SWEHelper.getPropertyUri("IsotopeName")) + .build()) + .addField("type", createText() + .label("Isotope Type") + .definition(SWEHelper.getPropertyUri("IsotopeType")) + .build()) + .addField("confidence", createQuantity() + .label("Confidence") + .definition(SWEHelper.getPropertyUri("Confidence")) + .build()) + .addField("confidenceStr", createText() + .label("Confidence String") + .definition(SWEHelper.getPropertyUri("ConfidenceString")) + .build()) + .addField("countRate", createQuantity() + .label("Count Rate") + .definition(SWEHelper.getPropertyUri("CountRate")) + .build()) + .build()) + .build()) + .addField("analysisWarningsCount", createCount() + .label("Analysis Warnings Count") + .id("analysisWarningsCount") + .definition(SWEHelper.getPropertyUri("AnalysisWarningsCount")) + .build()) + .addField("analysisWarnings", createArray() + .withVariableSize("analysisWarningsCount") + .definition(SWEHelper.getPropertyUri("AnalysisWarnings")) + .withElement("warning", createText() + .label("Warning") + .definition(SWEHelper.getPropertyUri("Warning")) + .build()) + .build()) + .addField("estimatedDose", createQuantity() + .label("Estimated Dose") + .definition(SWEHelper.getPropertyUri("EstimatedDose")) + .build()) + .addField("chi2", createQuantity() + .label("Chi Squared") + .definition(SWEHelper.getPropertyUri("ChiSquared")) + .build()) + .addField("analysisError", createCount() + .label("Analysis Error") + .definition(SWEHelper.getPropertyUri("AnalysisError")) + .build()) + .addField("errorMessage", createText() + .label("Error Message") + .definition(SWEHelper.getPropertyUri("ErrorMessage")) + .build()) + .addField("drf", createText() + .label("Detector Response Function") + .definition(SWEHelper.getPropertyUri("DRF")) + .build()) + .addField("isotopeString", createText() + .label("Isotope String") + .definition(SWEHelper.getPropertyUri("IsotopeString")) + .build()) + .build(); + } + } \ No newline at end of file diff --git a/sensors/sensorhub-utils-rad/src/main/java/org/sensorhub/impl/utils/rad/model/IsotopeAnalysis.java b/sensors/sensorhub-utils-rad/src/main/java/org/sensorhub/impl/utils/rad/model/IsotopeAnalysis.java new file mode 100644 index 00000000..5148f16b --- /dev/null +++ b/sensors/sensorhub-utils-rad/src/main/java/org/sensorhub/impl/utils/rad/model/IsotopeAnalysis.java @@ -0,0 +1,70 @@ +package org.sensorhub.impl.utils.rad.model; + +public class IsotopeAnalysis { + + private String name; + private String type; + private float confidence; + private String confidenceStr; + private float countRate; + + public String getName() { + return name; + } + + public String getType() { + return type; + } + + public float getConfidence() { + return confidence; + } + + public String getConfidenceStr() { + return confidenceStr; + } + + public float getCountRate() { + return countRate; + } + + private IsotopeAnalysis() {} + + public static class Builder { + + private final IsotopeAnalysis instance; + + public Builder() { + this.instance = new IsotopeAnalysis(); + } + + public IsotopeAnalysis.Builder name(String name) { + this.instance.name = name; + return IsotopeAnalysis.Builder.this; + } + + public IsotopeAnalysis.Builder type(String type) { + this.instance.type = type; + return IsotopeAnalysis.Builder.this; + } + + public IsotopeAnalysis.Builder confidence(float confidence) { + this.instance.confidence = confidence; + return IsotopeAnalysis.Builder.this; + } + + public IsotopeAnalysis.Builder confidenceStr(String confidenceStr) { + this.instance.confidenceStr = confidenceStr; + return IsotopeAnalysis.Builder.this; + } + + public IsotopeAnalysis.Builder countRate(float countRate) { + this.instance.countRate = countRate; + return IsotopeAnalysis.Builder.this; + } + + public IsotopeAnalysis build() { + return this.instance; + } + } +} diff --git a/sensors/sensorhub-utils-rad/src/main/java/org/sensorhub/impl/utils/rad/model/Occupancy.java b/sensors/sensorhub-utils-rad/src/main/java/org/sensorhub/impl/utils/rad/model/Occupancy.java index 555a4e08..4c143a30 100644 --- a/sensors/sensorhub-utils-rad/src/main/java/org/sensorhub/impl/utils/rad/model/Occupancy.java +++ b/sensors/sensorhub-utils-rad/src/main/java/org/sensorhub/impl/utils/rad/model/Occupancy.java @@ -23,6 +23,7 @@ public class Occupancy { private int maxNeutronCount; private List adjudicatedIds = new ArrayList<>(); private List videoPaths = new ArrayList<>(); + private List webIdObsIds = new ArrayList<>(); public int getOccupancyCount() { return occupancyCount; @@ -64,6 +65,10 @@ public List getVideoPaths() { return videoPaths; } + public List getWebIdObsIds() { + return webIdObsIds; + } + public double getSamplingTime() { return samplingTime; } @@ -131,6 +136,11 @@ public Builder videoPaths(List videoPaths) { return this; } + public Builder webIdObsIds(List webIdObsIds) { + instance.webIdObsIds = webIdObsIds; + return this; + } + public Occupancy build() { return instance; } @@ -145,8 +155,12 @@ public void addVideoPath(String videoPath) { this.videoPaths.add(videoPath); } + public void addWebIdObsId(String webIdObsId) { + this.webIdObsIds.add(webIdObsId); + } + public static DataBlock fromOccupancy(Occupancy occupancy) { - OccupancyOutput output = new OccupancyOutput(new SensorSystem()); + OccupancyOutput output = new OccupancyOutput<>(new SensorSystem()); DataComponent resultStructure = output.getRecordDescription(); DataBlock dataBlock = resultStructure.createDataBlock(); dataBlock.updateAtomCount(); @@ -192,6 +206,20 @@ public static DataBlock fromOccupancy(Occupancy occupancy) { } } + int webIdObsIdsCount = occupancy.getWebIdObsIds().size(); + dataBlock.setDoubleValue(index++, webIdObsIdsCount); + + var webIdObsIdsArray = ((DataArrayImpl) resultStructure.getComponent("webIdObsIds")); + + if (webIdObsIdsCount > 0) { + webIdObsIdsArray.updateSize(); + dataBlock.updateAtomCount(); + + for (int i = 0; i < occupancy.getWebIdObsIds().size(); i++) { + dataBlock.setStringValue(index++, occupancy.getWebIdObsIds().get(i)); + } + } + return dataBlock; } @@ -219,6 +247,15 @@ public static Occupancy toOccupancy(DataBlock dataBlock) { for (int i = 0; i < videoPathCount; i++) videoPaths.add(dataBlock.getStringValue(index++)); + List webIdObsIds = new ArrayList<>(); + try { + var webIdObsIdsCount = dataBlock.getIntValue(index++); + for (int i = 0; i < webIdObsIdsCount; i++) + webIdObsIds.add(dataBlock.getStringValue(index++)); + } catch (Exception ignored) { + // backwards compatibility: old observations may not have webIdObsIds fields + } + return new Builder() .samplingTime(samplingTime) .occupancyCount(occupancyCount) @@ -231,6 +268,7 @@ public static Occupancy toOccupancy(DataBlock dataBlock) { .neutronAlarm(neutronAlarm) .adjudicatedIds(cmdIds) .videoPaths(videoPaths) + .webIdObsIds(webIdObsIds) .build(); } } diff --git a/sensors/sensorhub-utils-rad/src/main/java/org/sensorhub/impl/utils/rad/model/WebIdAnalysis.java b/sensors/sensorhub-utils-rad/src/main/java/org/sensorhub/impl/utils/rad/model/WebIdAnalysis.java new file mode 100644 index 00000000..82a990d3 --- /dev/null +++ b/sensors/sensorhub-utils-rad/src/main/java/org/sensorhub/impl/utils/rad/model/WebIdAnalysis.java @@ -0,0 +1,271 @@ +package org.sensorhub.impl.utils.rad.model; + +import net.opengis.swe.v20.DataArray; +import net.opengis.swe.v20.DataBlock; +import net.opengis.swe.v20.DataComponent; +import org.sensorhub.impl.utils.rad.RADHelper; + +import java.time.Instant; +import java.util.ArrayList; +import java.util.List; + +public class WebIdAnalysis { + + private Instant sampleTime; + + private List isotopes; + private String isotopeString; + private String drf; + + private double estimatedDose; + private double chi2; + + private int analysisError; + private String errorMessage; + private List analysisWarnings; + + private String occupancyObsId; + + private String rawJson; + + private WebIdAnalysis() {} + + public boolean isSuccessful() { + return analysisError == 0; + } + + public boolean hasError() { + return analysisError != 0; + } + + public List getIsotopes() { + return isotopes; + } + + public String getIsotopeString() { + return isotopeString; + } + + public String getDrf() { + return drf; + } + + public double getEstimatedDose() { + return estimatedDose; + } + + public double getChi2() { + return chi2; + } + + public int getAnalysisError() { + return analysisError; + } + + public String getErrorMessage() { + return errorMessage; + } + + public List getAnalysisWarnings() { + return analysisWarnings; + } + + public String getOccupancyObsId() { + return occupancyObsId; + } + + public Instant getSampleTime() { + return sampleTime; + } + + public void setSampleTime(Instant sampleTime) { + this.sampleTime = sampleTime; + } + + public void setOccupancyObsId(String occupancyObsId) { + this.occupancyObsId = occupancyObsId; + } + + public void setRawJson(String rawJson) { + this.rawJson = rawJson; + } + + @Override + public String toString() { + return this.rawJson; + } + + public static class Builder { + + private final WebIdAnalysis instance; + + public Builder() { + this.instance = new WebIdAnalysis(); + } + + public WebIdAnalysis.Builder sampleTime(Instant sampleTime) { + this.instance.sampleTime = sampleTime; + return WebIdAnalysis.Builder.this; + } + + public WebIdAnalysis.Builder isotopes(List isotopes) { + this.instance.isotopes = isotopes; + return WebIdAnalysis.Builder.this; + } + + public WebIdAnalysis.Builder isotopeString(String isotopeString) { + this.instance.isotopeString = isotopeString; + return WebIdAnalysis.Builder.this; + } + + public WebIdAnalysis.Builder drf(String drf) { + this.instance.drf = drf; + return WebIdAnalysis.Builder.this; + } + + public WebIdAnalysis.Builder estimatedDose(double estimatedDose) { + this.instance.estimatedDose = estimatedDose; + return WebIdAnalysis.Builder.this; + } + + public WebIdAnalysis.Builder chi2(double chi2) { + this.instance.chi2 = chi2; + return WebIdAnalysis.Builder.this; + } + + public WebIdAnalysis.Builder analysisError(int analysisError) { + this.instance.analysisError = analysisError; + return WebIdAnalysis.Builder.this; + } + + public WebIdAnalysis.Builder errorMessage(String errorMessage) { + this.instance.errorMessage = errorMessage; + return WebIdAnalysis.Builder.this; + } + + public WebIdAnalysis.Builder analysisWarnings(List analysisWarnings) { + this.instance.analysisWarnings = analysisWarnings; + return WebIdAnalysis.Builder.this; + } + + public WebIdAnalysis.Builder occupancyObsId(String occupancyObsId) { + this.instance.occupancyObsId = occupancyObsId; + return WebIdAnalysis.Builder.this; + } + + public WebIdAnalysis build() { + return this.instance; + } + } + + public static DataBlock fromWebIdAnalysis(WebIdAnalysis analysis) { + RADHelper radHelper = new RADHelper(); + DataComponent recordStructure = radHelper.createWebIdRecord(); + DataBlock dataBlock = recordStructure.createDataBlock(); + recordStructure.setData(dataBlock); + + int index = 0; + + dataBlock.setTimeStamp(index++, analysis.getSampleTime()); + + // isotopes + int numIsotopes = analysis.getIsotopes().size(); + dataBlock.setIntValue(index++, numIsotopes); + + // update isotope array size + var isotopesArray = ((DataArray) recordStructure.getComponent("isotopes")); + isotopesArray.updateSize(); + dataBlock.updateAtomCount(); + + // populate isotope analyses + for (int i = 0; i < numIsotopes; i++) { + var isotope = analysis.getIsotopes().get(i); + dataBlock.setStringValue(index++, isotope.getName()); + dataBlock.setStringValue(index++, isotope.getType()); + dataBlock.setFloatValue(index++, isotope.getConfidence()); + dataBlock.setStringValue(index++, isotope.getConfidenceStr()); + dataBlock.setFloatValue(index++, isotope.getCountRate()); + } + + // populate other fields + dataBlock.setStringValue(index++, analysis.getIsotopeString() == null || analysis.getIsotopeString().isBlank() ? "" : analysis.getIsotopeString()); + dataBlock.setStringValue(index++, analysis.getDrf() == null || analysis.getDrf().isBlank() ? "" : analysis.getDrf()); + dataBlock.setDoubleValue(index++, analysis.getEstimatedDose()); + dataBlock.setDoubleValue(index++, analysis.getChi2()); + dataBlock.setStringValue(index++, analysis.getErrorMessage() == null || analysis.getErrorMessage().isBlank() ? "" : analysis.getErrorMessage()); + + // analysis warnings + int numWarnings = analysis.getAnalysisWarnings().size(); + dataBlock.setIntValue(index++, numWarnings); + + // update analysis warnings array size + var warningsArray = ((DataArray) recordStructure.getComponent("analysisWarnings")); + warningsArray.updateSize(); + dataBlock.updateAtomCount(); + + // populate warnings + for (int i = 0; i < numWarnings; i++) { + var warning = analysis.getAnalysisWarnings().get(i); + dataBlock.setStringValue(index++, warning); + } + + dataBlock.setStringValue(index, analysis.getOccupancyObsId().isBlank() ? "" : analysis.getOccupancyObsId()); + + return dataBlock; + } + + public static WebIdAnalysis toWebIdAnalysis(DataBlock dataBlock) { + int index = 0; + + var timestamp = dataBlock.getTimeStamp(index++); + + // isotopes + int numIsotopes = dataBlock.getIntValue(index++); + List isotopes = new ArrayList<>(); + for (int i = 0; i < numIsotopes; i++) { + var name = dataBlock.getStringValue(index++); + var type = dataBlock.getStringValue(index++); + var confidence = dataBlock.getFloatValue(index++); + var confidenceStr = dataBlock.getStringValue(index++); + var countRate = dataBlock.getFloatValue(index++); + IsotopeAnalysis isotope = new IsotopeAnalysis.Builder() + .name(name) + .type(type) + .confidence(confidence) + .confidenceStr(confidenceStr) + .countRate(countRate) + .build(); + + isotopes.add(isotope); + } + + // other fields + var isotopeStr = dataBlock.getStringValue(index++); + var drf = dataBlock.getStringValue(index++); + var estimatedDose = dataBlock.getDoubleValue(index++); + var chi2 = dataBlock.getDoubleValue(index++); + var errorMessage = dataBlock.getStringValue(index++); + + // warnings + int numWarnings = dataBlock.getIntValue(index++); + List warnings = new ArrayList<>(); + for (int i = 0; i < numWarnings; i++) { + var warning = dataBlock.getStringValue(index++); + warnings.add(warning); + } + + var occupancyObsId = dataBlock.getStringValue(index); + + return new WebIdAnalysis.Builder() + .sampleTime(timestamp) + .isotopes(isotopes) + .isotopeString(isotopeStr) + .drf(drf) + .estimatedDose(estimatedDose) + .chi2(chi2) + .errorMessage(errorMessage) + .analysisWarnings(warnings) + .occupancyObsId(occupancyObsId) + .build(); + } +} diff --git a/sensors/sensorhub-utils-rad/src/main/java/org/sensorhub/impl/utils/rad/output/OccupancyOutput.java b/sensors/sensorhub-utils-rad/src/main/java/org/sensorhub/impl/utils/rad/output/OccupancyOutput.java index 99cf9374..e70889e7 100644 --- a/sensors/sensorhub-utils-rad/src/main/java/org/sensorhub/impl/utils/rad/output/OccupancyOutput.java +++ b/sensors/sensorhub-utils-rad/src/main/java/org/sensorhub/impl/utils/rad/output/OccupancyOutput.java @@ -53,6 +53,8 @@ public OccupancyOutput(SensorType parentSensor) { var adjudicatedIds = radHelper.createAdjudicatedIdsArray(); var videoPathCount = radHelper.createVideoPathCount(); var videoPaths = radHelper.createVideoPathsArray(); + var webIdObsIdsCount = radHelper.createWebIdObsIdsCount(); + var webIdObsIds = radHelper.createWebIdObsIdsArray(); dataStruct = radHelper.createRecord() .name(getName()) @@ -73,6 +75,8 @@ public OccupancyOutput(SensorType parentSensor) { .addField(adjudicatedIds.getName(), adjudicatedIds) .addField(videoPathCount.getName(), videoPathCount) .addField(videoPaths.getName(), videoPaths) + .addField(webIdObsIdsCount.getName(), webIdObsIdsCount) + .addField(webIdObsIds.getName(), webIdObsIds) .build(); dataEncoding = new TextEncodingImpl(",", "\n"); diff --git a/services/sensorhub-service-bucket/build.gradle b/services/sensorhub-service-bucket/build.gradle index f49acbd1..f9da3145 100644 --- a/services/sensorhub-service-bucket/build.gradle +++ b/services/sensorhub-service-bucket/build.gradle @@ -4,6 +4,9 @@ version = '1.1.0' dependencies { implementation 'org.sensorhub:sensorhub-core:' + oshCoreVersion + implementation 'org.sensorhub:sensorhub-webui-core:' + oshCoreVersion + implementation 'commons-fileupload:commons-fileupload:1.5' + implementation 'commons-io:commons-io:2.15.1' } // add info to OSGi manifest @@ -25,4 +28,3 @@ ext.pom >>= { } } } - diff --git a/services/sensorhub-service-bucket/src/main/java/com/botts/api/service/bucket/IObjectHandler.java b/services/sensorhub-service-bucket/src/main/java/com/botts/api/service/bucket/IObjectHandler.java index 642a2995..43b1ff86 100644 --- a/services/sensorhub-service-bucket/src/main/java/com/botts/api/service/bucket/IObjectHandler.java +++ b/services/sensorhub-service-bucket/src/main/java/com/botts/api/service/bucket/IObjectHandler.java @@ -1,7 +1,13 @@ package com.botts.api.service.bucket; +import javax.servlet.http.HttpServletRequest; + public interface IObjectHandler extends IResourceHandler { String getObjectPattern(); + default boolean canHandleRequest(HttpServletRequest request) { + return false; + } + } diff --git a/services/sensorhub-service-bucket/src/main/java/com/botts/impl/service/bucket/Activator.java b/services/sensorhub-service-bucket/src/main/java/com/botts/impl/service/bucket/Activator.java index 9070e3ef..d8e39a40 100644 --- a/services/sensorhub-service-bucket/src/main/java/com/botts/impl/service/bucket/Activator.java +++ b/services/sensorhub-service-bucket/src/main/java/com/botts/impl/service/bucket/Activator.java @@ -13,7 +13,7 @@ Developer are Copyright (C) 2025 the Initial Developer. All Rights Reserved. ******************************************************************************/ -package com.botts.impl.service.oscar; +package com.botts.impl.service.bucket; import org.osgi.framework.BundleActivator; import org.sensorhub.utils.OshBundleActivator; diff --git a/services/sensorhub-service-bucket/src/main/java/com/botts/impl/service/bucket/filesystem/FileSystemBucketStore.java b/services/sensorhub-service-bucket/src/main/java/com/botts/impl/service/bucket/filesystem/FileSystemBucketStore.java index 1bec80b2..d65fdeb5 100644 --- a/services/sensorhub-service-bucket/src/main/java/com/botts/impl/service/bucket/filesystem/FileSystemBucketStore.java +++ b/services/sensorhub-service-bucket/src/main/java/com/botts/impl/service/bucket/filesystem/FileSystemBucketStore.java @@ -29,20 +29,37 @@ public class FileSystemBucketStore implements IBucketStore { private final Path rootDirectory; public FileSystemBucketStore(Path rootDirectory) throws IOException { - this.rootDirectory = rootDirectory; - if (!Files.exists(rootDirectory)) { - Files.createDirectories(rootDirectory); + this.rootDirectory = rootDirectory.toAbsolutePath().normalize(); + if (!Files.exists(this.rootDirectory)) { + Files.createDirectories(this.rootDirectory); } } - private Path getBucketPath(String bucketName) { - return rootDirectory.resolve(bucketName); + private Path getBucketPath(String bucketName) throws DataStoreException { + Path path = rootDirectory.resolve(bucketName).toAbsolutePath().normalize(); + if (!path.startsWith(rootDirectory)) { + throw new DataStoreException("Illegal bucket name: " + bucketName); + } + return path; + } + + private Path getObjectPath(String bucketName, String key) throws DataStoreException { + Path bucketPath = getBucketPath(bucketName); + Path objectPath = bucketPath.resolve(key).toAbsolutePath().normalize(); + if (!objectPath.startsWith(bucketPath)) { + throw new DataStoreException("Illegal object key: " + key); + } + return objectPath; } @Override public boolean bucketExists(String bucketName) { - Path path = getBucketPath(bucketName); - return Files.exists(path); + try { + Path path = getBucketPath(bucketName); + return Files.exists(path); + } catch (DataStoreException e) { + return false; + } } @Override @@ -90,13 +107,24 @@ public long getNumBuckets() { @Override public boolean objectExists(String bucketName, String objectName) { - Path path = getBucketPath(bucketName).resolve(objectName); - return Files.exists(path) && path.toFile().isFile(); + try { + Path path = getObjectPath(bucketName, objectName); + return Files.exists(path) && path.toFile().isFile(); + } catch (DataStoreException e) { + return false; + } } @Override public boolean objectExists(String relativePath) { - return Files.exists(getBucketPath(relativePath)); + try { + Path path = rootDirectory.resolve(relativePath).toAbsolutePath().normalize(); + if (!path.startsWith(rootDirectory)) + return false; + return Files.exists(path); + } catch (Exception e) { + return false; + } } @Override @@ -115,12 +143,15 @@ public String createObject(String bucketName, InputStream data, Map metadata) throws DataStoreException { try { - Path path = getBucketPath(bucketName); - if (!Files.exists(path)) + Path bucketPath = getBucketPath(bucketName); + if (!Files.exists(bucketPath)) throw new DataStoreException(BUCKET_NOT_FOUND, new IllegalArgumentException()); - Path resolved = path.resolve(key); - if (!Files.exists(resolved)) - Files.createDirectories(resolved); + + Path resolved = getObjectPath(bucketName, key); + Path parent = resolved.getParent(); + if (parent != null && !Files.exists(parent)) + Files.createDirectories(parent); + Files.copy(data, resolved, StandardCopyOption.REPLACE_EXISTING); } catch (IOException e) { throw new DataStoreException(FAILED_PUT_OBJECT + bucketName, e); @@ -129,16 +160,20 @@ public void putObject(String bucketName, String key, InputStream data, Map metadata) throws DataStoreException { - Path path = getBucketPath(bucketName); - if (!Files.exists(path)) - throw new DataStoreException(BUCKET_NOT_FOUND, new IllegalArgumentException()); try { - var filePath = path.resolve(key).toFile().toPath(); - if (!Files.exists(filePath)) { - Files.createDirectories(filePath.getParent()); - Files.createFile(path.resolve(key)); - } - return new FileOutputStream(path.resolve(key).toFile()); + Path bucketPath = getBucketPath(bucketName); + if (!Files.exists(bucketPath)) + throw new DataStoreException(BUCKET_NOT_FOUND, new IllegalArgumentException()); + + Path resolved = getObjectPath(bucketName, key); + Path parent = resolved.getParent(); + if (parent != null && !Files.exists(parent)) + Files.createDirectories(parent); + + if (!Files.exists(resolved)) + Files.createFile(resolved); + + return new FileOutputStream(resolved.toFile()); } catch (IOException e) { throw new DataStoreException(FAILED_PUT_OBJECT + bucketName, e); } @@ -147,7 +182,7 @@ public OutputStream putObject(String bucketName, String key, Map @Override public InputStream getObject(String bucketName, String key) throws DataStoreException { try { - Path file = getBucketPath(bucketName).resolve(key); + Path file = getObjectPath(bucketName, key); if (!Files.exists(file)) throw new DataStoreException(OBJECT_NOT_FOUND + bucketName, new IllegalArgumentException()); return Files.newInputStream(file); @@ -158,17 +193,17 @@ public InputStream getObject(String bucketName, String key) throws DataStoreExce @Override public long getObjectSize(String bucketName, String key) throws DataStoreException { - Path file = getBucketPath(bucketName).resolve(key); + Path file = getObjectPath(bucketName, key); if (!Files.exists(file)) throw new DataStoreException(OBJECT_NOT_FOUND + bucketName, new IllegalArgumentException()); if (!file.toFile().isFile()) - throw new DataStoreException("Object is not readable"); + throw new DataStoreException(org.sensorhub.ui.I18N.get("error.bucket.not_readable")); return file.toFile().length(); } @Override public String getObjectMimeType(String bucketName, String key) throws DataStoreException { - Path path = getBucketPath(bucketName).resolve(key); + Path path = getObjectPath(bucketName, key); if (!Files.exists(path)) throw new DataStoreException(OBJECT_NOT_FOUND + bucketName, new IllegalArgumentException()); @@ -187,14 +222,14 @@ public String getObjectMimeType(String bucketName, String key) throws DataStoreE return "application/octet-stream"; } catch (IOException e) { - throw new DataStoreException("Unable to resolve mime type", e); + throw new DataStoreException(org.sensorhub.ui.I18N.get("error.bucket.resolve_mime"), e); } } @Override public void deleteObject(String bucketName, String key) throws DataStoreException { try { - Path file = getBucketPath(bucketName).resolve(key); + Path file = getObjectPath(bucketName, key); Files.deleteIfExists(file); } catch (IOException e) { throw new DataStoreException(FAILED_DELETE_OBJECT + bucketName, e); @@ -219,12 +254,14 @@ public List listObjects(String bucketName) throws DataStoreException { @Override public long getNumObjects(String bucketName) { - Path path = getBucketPath(bucketName); - if (!Files.exists(path)) - return -1; - try (Stream stream = Files.walk(path)) { - return stream.filter(Files::isRegularFile).count(); - } catch (IOException e) { + try { + Path path = getBucketPath(bucketName); + if (!Files.exists(path)) + return -1; + try (Stream stream = Files.walk(path)) { + return stream.filter(Files::isRegularFile).count(); + } + } catch (IOException | DataStoreException e) { return -1; } } @@ -235,7 +272,7 @@ public String getResourceURI(String bucketName, String key) throws DataStoreExce throw new DataStoreException(BUCKET_NOT_FOUND); if (!objectExists(bucketName, key)) throw new DataStoreException(OBJECT_NOT_FOUND + bucketName); - return rootDirectory.resolve(bucketName).resolve(key).toString(); + return getObjectPath(bucketName, key).toString(); } @Override diff --git a/services/sensorhub-service-bucket/src/main/java/com/botts/impl/service/bucket/handler/MultipartHandler.java b/services/sensorhub-service-bucket/src/main/java/com/botts/impl/service/bucket/handler/MultipartHandler.java new file mode 100644 index 00000000..4186abee --- /dev/null +++ b/services/sensorhub-service-bucket/src/main/java/com/botts/impl/service/bucket/handler/MultipartHandler.java @@ -0,0 +1,171 @@ +package com.botts.impl.service.bucket.handler; + +import com.botts.api.service.bucket.IBucketStore; +import com.botts.impl.service.bucket.util.InvalidRequestException; +import com.botts.impl.service.bucket.util.MultipartRequestParser; +import com.botts.impl.service.bucket.util.RequestContext; +import com.botts.impl.service.bucket.util.ServiceErrors; +import com.google.gson.JsonArray; +import org.sensorhub.api.datastore.DataStoreException; + +import javax.servlet.http.HttpServletResponse; +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +public record MultipartHandler(IBucketStore bucketStore) { + + /** + * Handle POST with multipart/form-data + * Stores each file using its multipart filename as the key, falling back to a + * UUID when no filename is provided. Returns a JSON array of relative resource URIs. + * + * @param ctx Request context + * @throws IOException on I/O errors + * @throws SecurityException on permission errors + */ + public void handleMultipartPost(RequestContext ctx) + throws IOException, SecurityException { + + var bucketName = ctx.getBucketName(); + var sec = ctx.getSecurityHandler(); + sec.checkPermission(sec.getBucketPermission(bucketName).create); + + MultipartRequestParser.MultipartParseResult result = null; + try { + // Parse multipart request + result = MultipartRequestParser.parse(ctx.getRequest()); + + // Extract metadata from form fields + Map baseMetadata = new HashMap<>(ctx.getHeaders()); + + String customContentType = result.formFields().get("contentType"); + String tags = result.formFields().get("tags"); + String description = result.formFields().get("description"); + + List resourceURIs = new ArrayList<>(); + for (MultipartRequestParser.MultipartFile file : result.files()) { + + // Build metadata for this file + Map fileMetadata = new HashMap<>(baseMetadata); + + // Use file's content type or override from form field + if (customContentType != null && !customContentType.isBlank()) { + fileMetadata.put("Content-Type", customContentType); + } else if (file.contentType() != null) { + fileMetadata.put("Content-Type", file.contentType()); + } + + if (tags != null) { + fileMetadata.put("X-Tags", tags); + } + if (description != null) { + fileMetadata.put("X-Description", description); + } + if (file.fileName() != null) { + fileMetadata.put("X-Original-Filename", file.fileName()); + } + + // Use filename as key if available, otherwise fall back to UUID + String objectKey; + if (file.fileName() != null && !file.fileName().isBlank()) { + bucketStore.putObject(bucketName, file.fileName(), file.inputStream(), fileMetadata); + objectKey = file.fileName(); + } else { + objectKey = bucketStore.createObject(bucketName, file.inputStream(), fileMetadata); + if (objectKey == null) { + throw ServiceErrors.internalError(IBucketStore.FAILED_CREATE_OBJECT + bucketName); + } + } + + resourceURIs.add(bucketStore.getRelativeResourceURI(bucketName, objectKey)); + } + + ctx.getResponse().setStatus(HttpServletResponse.SC_CREATED); + + JsonArray jsonArray = new JsonArray(); + for (var resourceURI : resourceURIs) + jsonArray.add(resourceURI); + ctx.getResponse().getWriter().write(jsonArray.toString()); + + } catch (InvalidRequestException e) { + throw e; + } catch (DataStoreException e) { + throw ServiceErrors.internalError(IBucketStore.FAILED_CREATE_OBJECT + bucketName); + } finally { + if (result != null) { + result.close(); + } + } + } + + /** + * Handle PUT with multipart/form-data + * Only accepts single file upload to specified key + * + * @param ctx Request context + * @throws InvalidRequestException if multiple files provided + * @throws IOException on I/O errors + * @throws SecurityException on permission errors + */ + public void handleMultipartPut(RequestContext ctx) + throws IOException, SecurityException { + + var bucketName = ctx.getBucketName(); + var objectKey = ctx.getObjectKey(); + var sec = ctx.getSecurityHandler(); + sec.checkPermission(sec.getBucketPermission(bucketName).put); + + MultipartRequestParser.MultipartParseResult result = null; + try { + result = MultipartRequestParser.parse(ctx.getRequest()); + + // PUT only accepts single file + if (result.files().size() > 1) { + throw ServiceErrors.badRequest( + "PUT only accepts single file. Use POST for multiple files." + ); + } + + MultipartRequestParser.MultipartFile file = result.files().get(0); + + // Build metadata + Map metadata = new HashMap<>(ctx.getHeaders()); + + String customContentType = result.formFields().get("contentType"); + if (customContentType != null && !customContentType.isBlank()) { + metadata.put("Content-Type", customContentType); + } else if (file.contentType() != null) { + metadata.put("Content-Type", file.contentType()); + } + + String tags = result.formFields().get("tags"); + String description = result.formFields().get("description"); + if (tags != null) metadata.put("X-Tags", tags); + if (description != null) metadata.put("X-Description", description); + if (file.fileName() != null) { + metadata.put("X-Original-Filename", file.fileName()); + } + + // Determine status code + int successStatus = bucketStore.objectExists(bucketName, objectKey) ? + HttpServletResponse.SC_OK : HttpServletResponse.SC_CREATED; + + // Put object + bucketStore.putObject(bucketName, objectKey, file.inputStream(), metadata); + + ctx.getResponse().setStatus(successStatus); + + } catch (InvalidRequestException e) { + throw e; + } catch (DataStoreException e) { + throw ServiceErrors.internalError(IBucketStore.FAILED_PUT_OBJECT + bucketName); + } finally { + if (result != null) { + result.close(); + } + } + } +} diff --git a/services/sensorhub-service-bucket/src/main/java/com/botts/impl/service/bucket/util/MultipartRequestParser.java b/services/sensorhub-service-bucket/src/main/java/com/botts/impl/service/bucket/util/MultipartRequestParser.java new file mode 100644 index 00000000..9d51c33c --- /dev/null +++ b/services/sensorhub-service-bucket/src/main/java/com/botts/impl/service/bucket/util/MultipartRequestParser.java @@ -0,0 +1,111 @@ +package com.botts.impl.service.bucket.util; + +import org.apache.commons.fileupload.FileItem; +import org.apache.commons.fileupload.FileUploadException; +import org.apache.commons.fileupload.disk.DiskFileItemFactory; +import org.apache.commons.fileupload.servlet.ServletFileUpload; + +import javax.servlet.http.HttpServletRequest; +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +public class MultipartRequestParser { + + private static final long MAX_FILE_SIZE = 100 * 1024 * 1024; // 100MB + private static final long MAX_REQUEST_SIZE = 200 * 1024 * 1024; // 200MB + private static final int FILE_SIZE_THRESHOLD = 1024 * 1024; // 1MB + private static final String MULTIPART = "multipart/"; + + /** + * Check if request has multipart content type. + * Unlike ServletFileUpload.isMultipartContent(), this supports PUT requests as well. + */ + private static boolean isMultipartContent(HttpServletRequest request) { + String contentType = request.getContentType(); + return contentType != null && contentType.toLowerCase().startsWith(MULTIPART); + } + + public record MultipartFile(String fieldName, String fileName, String contentType, InputStream inputStream, + long size) { + } + + public record MultipartParseResult(List files, Map formFields, + List fileItems) implements AutoCloseable { + @Override + public void close() { + for (FileItem item : fileItems) { + try { + item.delete(); + } catch (Exception ignored) {} + } + } + } + + // parse multipart request + public static MultipartParseResult parse(HttpServletRequest request) + throws InvalidRequestException { + + // Check content type directly to support both POST and PUT requests + // (ServletFileUpload.isMultipartContent only allows POST) + if (!isMultipartContent(request)) + throw ServiceErrors.badRequest("Not a multipart request"); + + DiskFileItemFactory factory = new DiskFileItemFactory(); + factory.setSizeThreshold(FILE_SIZE_THRESHOLD); + factory.setRepository(new File(System.getProperty("java.io.tmpdir"))); + + ServletFileUpload upload = new ServletFileUpload(factory); + upload.setFileSizeMax(MAX_FILE_SIZE); + upload.setSizeMax(MAX_REQUEST_SIZE); + upload.setHeaderEncoding("UTF-8"); + + List items; + try { + items = upload.parseRequest(request); + } catch (FileUploadException e) { + if (e.getMessage() != null && e.getMessage().contains("size")) { + throw ServiceErrors.badRequest("File size exceeds maximum allowed: " + + (MAX_FILE_SIZE / (1024 * 1024)) + "MB"); + } + throw ServiceErrors.badRequest("Failed to parse multipart request: " + e.getMessage()); + } + + List files = new ArrayList<>(); + Map formFields = new HashMap<>(); + + for (FileItem item : items) { + if (item.isFormField()) { + try { + formFields.put(item.getFieldName(), item.getString("UTF-8")); + } catch (Exception e) { + formFields.put(item.getFieldName(), item.getString()); + } + } else { + // file + if (item.getSize() > 0) { + try { + files.add(new MultipartFile( + item.getFieldName(), + item.getName(), + item.getContentType(), + item.getInputStream(), + item.getSize() + )); + } catch (IOException e) { + throw ServiceErrors.internalError("Failed to read uploaded file: " + e.getMessage()); + } + } + } + } + + if (files.isEmpty()) + throw ServiceErrors.badRequest("No files found in multipart request"); + + return new MultipartParseResult(files, formFields, items); + } +} diff --git a/services/sensorhub-service-bucket/src/main/java/com/botts/impl/service/bucket/util/RequestContext.java b/services/sensorhub-service-bucket/src/main/java/com/botts/impl/service/bucket/util/RequestContext.java index 6d9e1cf2..d7194314 100644 --- a/services/sensorhub-service-bucket/src/main/java/com/botts/impl/service/bucket/util/RequestContext.java +++ b/services/sensorhub-service-bucket/src/main/java/com/botts/impl/service/bucket/util/RequestContext.java @@ -94,4 +94,9 @@ public Map getHeaders() { return headers; } + public boolean isMultipartRequest() { + String contentType = request.getContentType(); + return contentType != null && contentType.toLowerCase().startsWith("multipart/form-data"); + } + } diff --git a/services/sensorhub-service-bucket/src/main/resources/com/botts/impl/service/bucket/Messages.properties b/services/sensorhub-service-bucket/src/main/resources/com/botts/impl/service/bucket/Messages.properties new file mode 100644 index 00000000..a22911d3 --- /dev/null +++ b/services/sensorhub-service-bucket/src/main/resources/com/botts/impl/service/bucket/Messages.properties @@ -0,0 +1,6 @@ +error.bucket.not_found=Bucket not found +error.bucket.failed_put=Failed to put object in bucket {0} +error.bucket.illegal_name=Illegal bucket name: {0} +error.bucket.illegal_key=Illegal object key: {0} +error.bucket.not_readable=Object is not readable +error.bucket.resolve_mime=Unable to resolve mime type diff --git a/services/sensorhub-service-oscar/src/main/java/com/botts/impl/service/oscar/cambio/CambioConverter.java b/services/sensorhub-service-oscar/src/main/java/com/botts/impl/service/oscar/cambio/CambioConverter.java new file mode 100644 index 00000000..8115add7 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/com/botts/impl/service/oscar/cambio/CambioConverter.java @@ -0,0 +1,363 @@ +package com.botts.impl.service.oscar.cambio; + +import gov.sandia.specutils.*; + +import java.io.*; +import java.nio.file.Files; +import java.util.*; + +public class CambioConverter { + + static { + SpecUtilsNativeLoader.load(); + } + + public CambioConverter() { + } + + public Set getSupportedInputFormats() { + Set formats = new LinkedHashSet<>(); + formats.add("n42"); + formats.add("N42_2006"); + formats.add("N42_2012"); + formats.add("Spc"); + formats.add("Exploranium"); + formats.add("Pcf"); + formats.add("Chn"); + formats.add("SpeIaea"); + formats.add("TxtOrCsv"); + formats.add("Cnf"); + formats.add("TracsMps"); + formats.add("Aram"); + formats.add("SPMDailyFile"); + formats.add("AmptekMca"); + formats.add("MicroRaider"); + formats.add("RadiaCode"); + formats.add("OrtecListMode"); + formats.add("LsrmSpe"); + formats.add("Tka"); + formats.add("MultiAct"); + formats.add("Phd"); + formats.add("Lzs"); + formats.add("ScanDataXml"); + formats.add("Json"); + formats.add("CaenHexagonGXml"); + return formats; + } + + public Set getSupportedOutputFormats() { + Set formats = new LinkedHashSet<>(); + formats.add("Txt"); + formats.add("Csv"); + formats.add("Pcf"); + formats.add("n42"); + formats.add("N42_2006"); + formats.add("N42_2012"); + formats.add("Chn"); + formats.add("SpcBinaryInt"); + formats.add("SpcBinaryFloat"); + formats.add("SpcAscii"); + formats.add("ExploraniumGr130v0"); + formats.add("ExploraniumGr135v2"); + formats.add("SpeIaea"); + formats.add("Cnf"); + formats.add("Tka"); + formats.add("HtmlD3"); + return formats; + } + + public SpectrumInfo readSpectrumInfo(File inputFile) throws CambioException { + return readSpectrumInfo(inputFile, ParserType.Auto); + } + + public SpectrumInfo readSpectrumInfo(File inputFile, ParserType parserType) throws CambioException { + SpecFile specFile = new SpecFile(); + try { + if (!specFile.load_file(inputFile.getAbsolutePath(), parserType, "")) { + throw new CambioException("Failed to load spectrum file: " + inputFile.getAbsolutePath()); + } + return extractSpectrumInfo(specFile, inputFile.getName()); + } finally { + specFile.delete(); + } + } + + public SpectrumInfo readSpectrumInfo(InputStream inputStream, String filename) throws CambioException { + return readSpectrumInfo(inputStream, filename, ParserType.Auto); + } + + public SpectrumInfo readSpectrumInfo(InputStream inputStream, String filename, ParserType parserType) throws CambioException { + File tempFile = null; + try { + tempFile = createTempFile(inputStream, filename); + return readSpectrumInfo(tempFile, parserType); + } catch (IOException e) { + throw new CambioException("Failed to read spectrum from stream", e); + } finally { + deleteTempFile(tempFile); + } + } + + public ConversionResult convert(ConversionRequest request) throws CambioException { + File tempInputFile = null; + SpecFile specFile = new SpecFile(); + + try { + File inputFile; + if (request.getInputFile() != null) { + inputFile = request.getInputFile(); + } else { + tempInputFile = createTempFile(request.getInputStream(), request.getInputFilename()); + inputFile = tempInputFile; + } + + if (!specFile.load_file(inputFile.getAbsolutePath(), request.getInputFormat(), "")) { + return new ConversionResult.Builder() + .successful(false) + .errorMessage("Failed to load spectrum file: " + inputFile.getAbsolutePath()) + .outputFormat(request.getOutputFormat()) + .build(); + } + + SpectrumInfo spectrumInfo = extractSpectrumInfo(specFile, inputFile.getName()); + List warnings = extractWarnings(specFile); + + if (request.getOutputFile() != null) { + writeToFile(specFile, request); + return new ConversionResult.Builder() + .successful(true) + .outputFile(request.getOutputFile()) + .outputFormat(request.getOutputFormat()) + .spectrumInfo(spectrumInfo) + .warnings(warnings) + .build(); + } else { + byte[] outputBytes = writeToBytes(specFile, request); + return new ConversionResult.Builder() + .successful(true) + .outputBytes(outputBytes) + .outputFormat(request.getOutputFormat()) + .spectrumInfo(spectrumInfo) + .warnings(warnings) + .build(); + } + } catch (Exception e) { + throw new CambioException("Conversion failed: " + e.getMessage(), e); + } finally { + specFile.delete(); + deleteTempFile(tempInputFile); + } + } + + public byte[] convertToN42(File inputFile) throws CambioException { + return convertToN42(inputFile, ParserType.Auto); + } + + public byte[] convertToN42(File inputFile, ParserType inputFormat) throws CambioException { + ConversionRequest request = new ConversionRequest.Builder() + .inputFile(inputFile) + .inputFormat(inputFormat) + .outputFormat(SaveSpectrumAsType.N42_2012) + .build(); + + ConversionResult result = convert(request); + if (!result.isSuccessful()) { + throw new CambioException("Conversion to N42 failed: " + result.getErrorMessage()); + } + return result.getOutputBytes(); + } + + public byte[] convertToN42(InputStream inputStream, String filename) throws CambioException { + return convertToN42(inputStream, filename, ParserType.Auto); + } + + public byte[] convertToN42(InputStream inputStream, String filename, ParserType inputFormat) throws CambioException { + ConversionRequest request = new ConversionRequest.Builder() + .inputStream(inputStream, filename) + .inputFormat(inputFormat) + .outputFormat(SaveSpectrumAsType.N42_2012) + .build(); + + ConversionResult result = convert(request); + if (!result.isSuccessful()) { + throw new CambioException("Conversion to N42 failed: " + result.getErrorMessage()); + } + return result.getOutputBytes(); + } + + public void convertToN42File(File inputFile, File outputFile) throws CambioException { + convertToN42File(inputFile, outputFile, ParserType.Auto); + } + + public void convertToN42File(File inputFile, File outputFile, ParserType inputFormat) throws CambioException { + ConversionRequest request = new ConversionRequest.Builder() + .inputFile(inputFile) + .inputFormat(inputFormat) + .outputFormat(SaveSpectrumAsType.N42_2012) + .outputFile(outputFile) + .build(); + + ConversionResult result = convert(request); + if (!result.isSuccessful()) { + throw new CambioException("Conversion to N42 file failed: " + result.getErrorMessage()); + } + } + + private SpectrumInfo extractSpectrumInfo(SpecFile specFile, String filename) { + List detectorNames = new ArrayList<>(); + StringVector names = specFile.detector_names(); + for (int i = 0; i < names.size(); i++) { + detectorNames.add(names.get(i)); + } + + List detectorNumbers = new ArrayList<>(); + IntVector numbers = specFile.detector_numbers(); + for (int i = 0; i < numbers.size(); i++) { + detectorNumbers.add(numbers.get(i)); + } + + List remarks = new ArrayList<>(); + StringVector remarksVector = specFile.remarks(); + for (int i = 0; i < remarksVector.size(); i++) { + remarks.add(remarksVector.get(i)); + } + + List parseWarnings = new ArrayList<>(); + StringVector warningsVector = specFile.parse_warnings(); + for (int i = 0; i < warningsVector.size(); i++) { + parseWarnings.add(warningsVector.get(i)); + } + + return new SpectrumInfo.Builder() + .uuid(specFile.uuid()) + .filename(filename) + .instrumentType(specFile.instrument_type()) + .manufacturer(specFile.manufacturer()) + .instrumentModel(specFile.instrument_model()) + .instrumentId(specFile.instrument_id()) + .detectorType(specFile.detector_type().toString()) + .locationName(specFile.measurement_location_name()) + .latitude(specFile.mean_latitude()) + .longitude(specFile.mean_longitude()) + .hasGpsInfo(specFile.has_gps_info()) + .gammaLiveTime(specFile.gamma_live_time()) + .gammaRealTime(specFile.gamma_real_time()) + .gammaCountSum(specFile.gamma_count_sum()) + .neutronCountSum(specFile.neutron_counts_sum()) + .containsNeutrons(specFile.contained_neutron()) + .numMeasurements(specFile.num_measurements()) + .numGammaChannels(specFile.num_gamma_channels()) + .detectorNames(detectorNames) + .detectorNumbers(detectorNumbers) + .remarks(remarks) + .parseWarnings(parseWarnings) + .build(); + } + + private List extractWarnings(SpecFile specFile) { + List warnings = new ArrayList<>(); + StringVector warningsVector = specFile.parse_warnings(); + for (int i = 0; i < warningsVector.size(); i++) { + warnings.add(warningsVector.get(i)); + } + return warnings; + } + + private void writeToFile(SpecFile specFile, ConversionRequest request) throws CambioException { + try { + if (request.getSampleNumbers() != null && request.getDetectorNumbers() != null) { + IntVector sampleNums = new IntVector(); + for (Integer num : request.getSampleNumbers()) { + sampleNums.add(num); + } + IntVector detNums = new IntVector(); + for (Integer num : request.getDetectorNumbers()) { + detNums.add(num); + } + specFile.write_to_file(request.getOutputFile().getAbsolutePath(), sampleNums, detNums, request.getOutputFormat()); + } else { + specFile.write_to_file(request.getOutputFile().getAbsolutePath(), request.getOutputFormat()); + } + } catch (Exception e) { + throw new CambioException("Failed to write output file: " + e.getMessage(), e); + } + } + + private byte[] writeToBytes(SpecFile specFile, ConversionRequest request) throws CambioException { + File tempOutputFile = null; + try { + String extension = getExtensionForFormat(request.getOutputFormat()); + tempOutputFile = File.createTempFile("cambio_output_", extension); + // SpecUtils won't overwrite existing files, so delete the temp file first + tempOutputFile.delete(); + + if (request.getSampleNumbers() != null && request.getDetectorNumbers() != null) { + IntVector sampleNums = new IntVector(); + for (Integer num : request.getSampleNumbers()) { + sampleNums.add(num); + } + IntVector detNums = new IntVector(); + for (Integer num : request.getDetectorNumbers()) { + detNums.add(num); + } + specFile.write_to_file(tempOutputFile.getAbsolutePath(), sampleNums, detNums, request.getOutputFormat()); + } else { + specFile.write_to_file(tempOutputFile.getAbsolutePath(), request.getOutputFormat()); + } + + return Files.readAllBytes(tempOutputFile.toPath()); + } catch (IOException e) { + throw new CambioException("Failed to write output to bytes: " + e.getMessage(), e); + } finally { + deleteTempFile(tempOutputFile); + } + } + + private String getExtensionForFormat(SaveSpectrumAsType format) { + if (format == SaveSpectrumAsType.N42_2006 || format == SaveSpectrumAsType.N42_2012) { + return ".n42"; + } else if (format == SaveSpectrumAsType.Pcf) { + return ".pcf"; + } else if (format == SaveSpectrumAsType.Csv) { + return ".csv"; + } else if (format == SaveSpectrumAsType.Txt) { + return ".txt"; + } else if (format == SaveSpectrumAsType.Chn) { + return ".chn"; + } else if (format == SaveSpectrumAsType.SpcBinaryInt || format == SaveSpectrumAsType.SpcBinaryFloat || format == SaveSpectrumAsType.SpcAscii) { + return ".spc"; + } else if (format == SaveSpectrumAsType.SpeIaea) { + return ".spe"; + } else if (format == SaveSpectrumAsType.Cnf) { + return ".cnf"; + } else if (format == SaveSpectrumAsType.Tka) { + return ".tka"; + } else if (format == SaveSpectrumAsType.HtmlD3) { + return ".html"; + } else { + return ".dat"; + } + } + + private File createTempFile(InputStream inputStream, String filename) throws IOException { + String extension = ""; + if (filename != null && filename.contains(".")) { + extension = filename.substring(filename.lastIndexOf(".")); + } + File tempFile = File.createTempFile("cambio_input_", extension); + try (FileOutputStream fos = new FileOutputStream(tempFile)) { + byte[] buffer = new byte[8192]; + int bytesRead; + while ((bytesRead = inputStream.read(buffer)) != -1) { + fos.write(buffer, 0, bytesRead); + } + } + return tempFile; + } + + private void deleteTempFile(File tempFile) { + if (tempFile != null && tempFile.exists()) { + tempFile.delete(); + } + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/com/botts/impl/service/oscar/cambio/CambioException.java b/services/sensorhub-service-oscar/src/main/java/com/botts/impl/service/oscar/cambio/CambioException.java new file mode 100644 index 00000000..e95df150 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/com/botts/impl/service/oscar/cambio/CambioException.java @@ -0,0 +1,50 @@ +package com.botts.impl.service.oscar.cambio; + +import java.io.IOException; + +public class CambioException extends IOException { + + private final String sourceFormat; + private final String targetFormat; + private final String filePath; + + public CambioException(String message) { + super(message); + this.sourceFormat = null; + this.targetFormat = null; + this.filePath = null; + } + + public CambioException(String message, Throwable cause) { + super(message, cause); + this.sourceFormat = null; + this.targetFormat = null; + this.filePath = null; + } + + public CambioException(String message, String sourceFormat, String targetFormat, String filePath) { + super(message); + this.sourceFormat = sourceFormat; + this.targetFormat = targetFormat; + this.filePath = filePath; + } + + public CambioException(String message, String sourceFormat, String targetFormat, String filePath, Throwable cause) { + super(message, cause); + this.sourceFormat = sourceFormat; + this.targetFormat = targetFormat; + this.filePath = filePath; + } + + public String getSourceFormat() { + return sourceFormat; + } + + public String getTargetFormat() { + return targetFormat; + } + + public String getFilePath() { + return filePath; + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/com/botts/impl/service/oscar/cambio/ConversionRequest.java b/services/sensorhub-service-oscar/src/main/java/com/botts/impl/service/oscar/cambio/ConversionRequest.java new file mode 100644 index 00000000..cbeaa9c8 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/com/botts/impl/service/oscar/cambio/ConversionRequest.java @@ -0,0 +1,124 @@ +package com.botts.impl.service.oscar.cambio; + +import gov.sandia.specutils.ParserType; +import gov.sandia.specutils.SaveSpectrumAsType; + +import java.io.File; +import java.io.InputStream; +import java.util.List; + +public class ConversionRequest { + + private File inputFile; + private InputStream inputStream; + private String inputFilename; + private ParserType inputFormat; + private SaveSpectrumAsType outputFormat; + private File outputFile; + private List sampleNumbers; + private List detectorNumbers; + + private ConversionRequest() {} + + public File getInputFile() { + return inputFile; + } + + public InputStream getInputStream() { + return inputStream; + } + + public String getInputFilename() { + return inputFilename; + } + + public ParserType getInputFormat() { + return inputFormat; + } + + public SaveSpectrumAsType getOutputFormat() { + return outputFormat; + } + + public File getOutputFile() { + return outputFile; + } + + public List getSampleNumbers() { + return sampleNumbers; + } + + public List getDetectorNumbers() { + return detectorNumbers; + } + + public static class Builder { + + private final ConversionRequest instance; + + public Builder() { + this.instance = new ConversionRequest(); + this.instance.inputFormat = ParserType.Auto; + this.instance.outputFormat = SaveSpectrumAsType.N42_2012; + } + + public Builder inputFile(File inputFile) { + this.instance.inputFile = inputFile; + return this; + } + + public Builder inputFile(String inputFilePath) { + this.instance.inputFile = new File(inputFilePath); + return this; + } + + public Builder inputStream(InputStream inputStream, String filename) { + this.instance.inputStream = inputStream; + this.instance.inputFilename = filename; + return this; + } + + public Builder inputFormat(ParserType inputFormat) { + this.instance.inputFormat = inputFormat; + return this; + } + + public Builder outputFormat(SaveSpectrumAsType outputFormat) { + this.instance.outputFormat = outputFormat; + return this; + } + + public Builder outputFile(File outputFile) { + this.instance.outputFile = outputFile; + return this; + } + + public Builder outputFile(String outputFilePath) { + this.instance.outputFile = new File(outputFilePath); + return this; + } + + public Builder sampleNumbers(List sampleNumbers) { + this.instance.sampleNumbers = sampleNumbers; + return this; + } + + public Builder detectorNumbers(List detectorNumbers) { + this.instance.detectorNumbers = detectorNumbers; + return this; + } + + public ConversionRequest build() { + if (this.instance.inputFile == null && this.instance.inputStream == null) { + throw new IllegalStateException("Either inputFile or inputStream is required"); + } + if (this.instance.inputFile != null && this.instance.inputStream != null) { + throw new IllegalStateException("Cannot specify both inputFile and inputStream"); + } + if (this.instance.outputFormat == null) { + throw new IllegalStateException("outputFormat is required"); + } + return this.instance; + } + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/com/botts/impl/service/oscar/cambio/ConversionResult.java b/services/sensorhub-service-oscar/src/main/java/com/botts/impl/service/oscar/cambio/ConversionResult.java new file mode 100644 index 00000000..3ec86fec --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/com/botts/impl/service/oscar/cambio/ConversionResult.java @@ -0,0 +1,99 @@ +package com.botts.impl.service.oscar.cambio; + +import gov.sandia.specutils.SaveSpectrumAsType; + +import java.io.File; +import java.util.List; + +public class ConversionResult { + + private boolean successful; + private File outputFile; + private byte[] outputBytes; + private SaveSpectrumAsType outputFormat; + private SpectrumInfo spectrumInfo; + private String errorMessage; + private List warnings; + + private ConversionResult() {} + + public boolean isSuccessful() { + return successful; + } + + public boolean hasError() { + return !successful; + } + + public File getOutputFile() { + return outputFile; + } + + public byte[] getOutputBytes() { + return outputBytes; + } + + public SaveSpectrumAsType getOutputFormat() { + return outputFormat; + } + + public SpectrumInfo getSpectrumInfo() { + return spectrumInfo; + } + + public String getErrorMessage() { + return errorMessage; + } + + public List getWarnings() { + return warnings; + } + + public static class Builder { + + private final ConversionResult instance; + + public Builder() { + this.instance = new ConversionResult(); + } + + public Builder successful(boolean successful) { + this.instance.successful = successful; + return this; + } + + public Builder outputFile(File outputFile) { + this.instance.outputFile = outputFile; + return this; + } + + public Builder outputBytes(byte[] outputBytes) { + this.instance.outputBytes = outputBytes; + return this; + } + + public Builder outputFormat(SaveSpectrumAsType outputFormat) { + this.instance.outputFormat = outputFormat; + return this; + } + + public Builder spectrumInfo(SpectrumInfo spectrumInfo) { + this.instance.spectrumInfo = spectrumInfo; + return this; + } + + public Builder errorMessage(String errorMessage) { + this.instance.errorMessage = errorMessage; + return this; + } + + public Builder warnings(List warnings) { + this.instance.warnings = warnings; + return this; + } + + public ConversionResult build() { + return this.instance; + } + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/com/botts/impl/service/oscar/cambio/SpectrumInfo.java b/services/sensorhub-service-oscar/src/main/java/com/botts/impl/service/oscar/cambio/SpectrumInfo.java new file mode 100644 index 00000000..d98ee573 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/com/botts/impl/service/oscar/cambio/SpectrumInfo.java @@ -0,0 +1,244 @@ +package com.botts.impl.service.oscar.cambio; + +import java.util.List; + +public class SpectrumInfo { + + private String uuid; + private String filename; + private String instrumentType; + private String manufacturer; + private String instrumentModel; + private String instrumentId; + private String detectorType; + private String locationName; + private double latitude; + private double longitude; + private boolean hasGpsInfo; + + private float gammaLiveTime; + private float gammaRealTime; + private double gammaCountSum; + private double neutronCountSum; + private boolean containsNeutrons; + + private long numMeasurements; + private long numGammaChannels; + private List detectorNames; + private List detectorNumbers; + private List remarks; + private List parseWarnings; + + private SpectrumInfo() {} + + public String getUuid() { + return uuid; + } + + public String getFilename() { + return filename; + } + + public String getInstrumentType() { + return instrumentType; + } + + public String getManufacturer() { + return manufacturer; + } + + public String getInstrumentModel() { + return instrumentModel; + } + + public String getInstrumentId() { + return instrumentId; + } + + public String getDetectorType() { + return detectorType; + } + + public String getLocationName() { + return locationName; + } + + public double getLatitude() { + return latitude; + } + + public double getLongitude() { + return longitude; + } + + public boolean hasGpsInfo() { + return hasGpsInfo; + } + + public float getGammaLiveTime() { + return gammaLiveTime; + } + + public float getGammaRealTime() { + return gammaRealTime; + } + + public double getGammaCountSum() { + return gammaCountSum; + } + + public double getNeutronCountSum() { + return neutronCountSum; + } + + public boolean containsNeutrons() { + return containsNeutrons; + } + + public long getNumMeasurements() { + return numMeasurements; + } + + public long getNumGammaChannels() { + return numGammaChannels; + } + + public List getDetectorNames() { + return detectorNames; + } + + public List getDetectorNumbers() { + return detectorNumbers; + } + + public List getRemarks() { + return remarks; + } + + public List getParseWarnings() { + return parseWarnings; + } + + public static class Builder { + + private final SpectrumInfo instance; + + public Builder() { + this.instance = new SpectrumInfo(); + } + + public Builder uuid(String uuid) { + this.instance.uuid = uuid; + return this; + } + + public Builder filename(String filename) { + this.instance.filename = filename; + return this; + } + + public Builder instrumentType(String instrumentType) { + this.instance.instrumentType = instrumentType; + return this; + } + + public Builder manufacturer(String manufacturer) { + this.instance.manufacturer = manufacturer; + return this; + } + + public Builder instrumentModel(String instrumentModel) { + this.instance.instrumentModel = instrumentModel; + return this; + } + + public Builder instrumentId(String instrumentId) { + this.instance.instrumentId = instrumentId; + return this; + } + + public Builder detectorType(String detectorType) { + this.instance.detectorType = detectorType; + return this; + } + + public Builder locationName(String locationName) { + this.instance.locationName = locationName; + return this; + } + + public Builder latitude(double latitude) { + this.instance.latitude = latitude; + return this; + } + + public Builder longitude(double longitude) { + this.instance.longitude = longitude; + return this; + } + + public Builder hasGpsInfo(boolean hasGpsInfo) { + this.instance.hasGpsInfo = hasGpsInfo; + return this; + } + + public Builder gammaLiveTime(float gammaLiveTime) { + this.instance.gammaLiveTime = gammaLiveTime; + return this; + } + + public Builder gammaRealTime(float gammaRealTime) { + this.instance.gammaRealTime = gammaRealTime; + return this; + } + + public Builder gammaCountSum(double gammaCountSum) { + this.instance.gammaCountSum = gammaCountSum; + return this; + } + + public Builder neutronCountSum(double neutronCountSum) { + this.instance.neutronCountSum = neutronCountSum; + return this; + } + + public Builder containsNeutrons(boolean containsNeutrons) { + this.instance.containsNeutrons = containsNeutrons; + return this; + } + + public Builder numMeasurements(long numMeasurements) { + this.instance.numMeasurements = numMeasurements; + return this; + } + + public Builder numGammaChannels(long numGammaChannels) { + this.instance.numGammaChannels = numGammaChannels; + return this; + } + + public Builder detectorNames(List detectorNames) { + this.instance.detectorNames = detectorNames; + return this; + } + + public Builder detectorNumbers(List detectorNumbers) { + this.instance.detectorNumbers = detectorNumbers; + return this; + } + + public Builder remarks(List remarks) { + this.instance.remarks = remarks; + return this; + } + + public Builder parseWarnings(List parseWarnings) { + this.instance.parseWarnings = parseWarnings; + return this; + } + + public SpectrumInfo build() { + return this.instance; + } + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/com/botts/impl/service/oscar/stats/StatisticsOutput.java b/services/sensorhub-service-oscar/src/main/java/com/botts/impl/service/oscar/stats/StatisticsOutput.java index 3deb625a..4ba0b824 100644 --- a/services/sensorhub-service-oscar/src/main/java/com/botts/impl/service/oscar/stats/StatisticsOutput.java +++ b/services/sensorhub-service-oscar/src/main/java/com/botts/impl/service/oscar/stats/StatisticsOutput.java @@ -18,7 +18,6 @@ import java.time.Instant; import java.time.temporal.ChronoUnit; import java.util.ArrayList; -import java.util.Calendar; import java.util.List; import java.util.Map; import java.util.HashMap; @@ -48,6 +47,10 @@ public class StatisticsOutput extends AbstractSensorOutput { private final IObsSystemDatabase database; private Map> observedPropertyToDataStreamIds; + private record LastStatisticObservationData(Instant timestamp, Statistics total) { + + } + public StatisticsOutput(OSCARSystem parentSensor, IObsSystemDatabase database, int samplingPeriod) { super(NAME, parentSensor); this.database = database; @@ -102,36 +105,39 @@ public void publishLatestStatistics() { long currentTime = System.currentTimeMillis(); DataBlock dataBlock = latestRecord == null ? recordDescription.createDataBlock() : latestRecord.renew(); + Instant now = Instant.now(); int i = 0; dataBlock.setLongValue(i++, currentTime/1000); // Get total counts from all observations - i = populateDataBlock(dataBlock, i, null, null); + LastStatisticObservationData lastStatisticObservationData = getLastObservation(); - // Get monthly counts - int currentDayOfMonth = Calendar.getInstance().get(Calendar.DAY_OF_MONTH); - var monthStart = Instant.now().minus(currentDayOfMonth-1, TimeUnit.DAYS.toChronoUnit()).truncatedTo(ChronoUnit.DAYS); - var lastDayOfMonth = Calendar.getInstance().getActualMaximum(Calendar.DAY_OF_MONTH); - var monthEnd = Instant.now().plus(lastDayOfMonth-currentDayOfMonth+1, TimeUnit.DAYS.toChronoUnit()).truncatedTo(ChronoUnit.DAYS); + if (lastStatisticObservationData != null) { + Instant lastTimestamp = lastStatisticObservationData.timestamp(); + Statistics previousTotal = lastStatisticObservationData.total(); + Instant exclusiveStart = lastTimestamp.plusNanos(1); + Statistics incrementalStats = getStats(exclusiveStart, now); - i = populateDataBlock(dataBlock, i, monthStart, monthEnd); + Statistics newTotal = previousTotal.add(incrementalStats); - // Get weekly counts - int currentDayOfWeek = Calendar.getInstance().get(Calendar.DAY_OF_WEEK); - var weekStart = Instant.now().minus(currentDayOfWeek-1, TimeUnit.DAYS.toChronoUnit()).truncatedTo(ChronoUnit.DAYS); - var lastDayOfWeek = Calendar.getInstance().getActualMaximum(Calendar.DAY_OF_WEEK); - var weekEnd = Instant.now().plus(lastDayOfWeek-currentDayOfWeek+1, TimeUnit.DAYS.toChronoUnit()).truncatedTo(ChronoUnit.DAYS); + i = populateDataBlockWithStats(dataBlock, i, newTotal); + } else { + getLogger().debug("No previous stats observation found, calculating from epoch to {}", now); + i = populateDataBlock(dataBlock, i, Instant.EPOCH, now); + } - i = populateDataBlock(dataBlock, i, weekStart, weekEnd); + // last 30 days + Instant monthStart = now.minus(30, ChronoUnit.DAYS); + i = populateDataBlock(dataBlock, i, monthStart, now); - // Get today's counts - int currentHour = Calendar.getInstance().get(Calendar.HOUR_OF_DAY); - var dayStart = Instant.now().minus(currentHour-1, TimeUnit.HOURS.toChronoUnit()).truncatedTo(ChronoUnit.DAYS); - var lastHour = Calendar.getInstance().getActualMaximum(Calendar.HOUR_OF_DAY); - var dayEnd = Instant.now().plus(lastHour-currentHour+1, TimeUnit.HOURS.toChronoUnit()).truncatedTo(ChronoUnit.DAYS); + // last 7 days + Instant weekStart = now.minus(7, ChronoUnit.DAYS); + i = populateDataBlock(dataBlock, i, weekStart, now); - populateDataBlock(dataBlock, i, dayStart, dayEnd); + // last 24 hours + Instant dayStart = now.minus(24, ChronoUnit.HOURS); + populateDataBlock(dataBlock, i, dayStart, now); latestRecord = dataBlock; latestRecordTime = currentTime; @@ -219,13 +225,14 @@ private long countObservations(IObsSystemDatabase database, String cqlValue, Ins var dsFilterBuilder = new DataStreamFilter.Builder() .withObservedProperties(observedProperty); - if (begin != null && end != null) - dsFilterBuilder = dsFilterBuilder.withValidTimeDuring(begin, end); - var dsFilter = dsFilterBuilder.build(); var obsBuilder = new ObsFilter.Builder().withDataStreams(dsFilter); + if (begin != null && end != null) { + obsBuilder.withPhenomenonTime().withRange(begin, end).done(); + } + if (cqlValue != null && !cqlValue.isBlank()) { obsBuilder.withCQLFilter(cqlValue); } @@ -233,6 +240,46 @@ private long countObservations(IObsSystemDatabase database, String cqlValue, Ins return database.getObservationStore().countMatchingEntries(obsBuilder.build()); } + /** + * get last observation + */ + private LastStatisticObservationData getLastObservation() { + var query = database.getObservationStore().select(new ObsFilter.Builder() + .withSystems().withUniqueIDs(parentSensor.getUniqueIdentifier()).done() + .withDataStreams(new DataStreamFilter.Builder() + .withOutputNames(NAME) + .build()) + .withLatestResult() + .build()); + + var observations = query.toList(); + + if (observations.isEmpty()) + return null; + + var result = observations.get(0).getResult(); + + long storedTimestampSeconds = result.getLongValue(0); + Instant timestamp = Instant.ofEpochSecond(storedTimestampSeconds); + + Statistics allTime = getLastObservationCount(result, 0); + + return new LastStatisticObservationData(timestamp, allTime); + } + + private Statistics getLastObservationCount(DataBlock dataBlock, int index) { + return new Statistics.Builder() + .numOccupancies(dataBlock.getLongValue(index + 1)) + .numGammaAlarms(dataBlock.getLongValue(index + 2)) + .numNeutronAlarms(dataBlock.getLongValue(index + 3)) + .numGammaNeutronAlarms(dataBlock.getLongValue(index + 4)) + .numFaults(dataBlock.getLongValue(index + 5)) + .numGammaFaults(dataBlock.getLongValue(index + 6)) + .numNeutronFaults(dataBlock.getLongValue(index + 7)) + .numTampers(dataBlock.getLongValue(index + 8)) + .build(); + } + @Override public DataComponent getRecordDescription() { return recordDescription; @@ -247,4 +294,4 @@ public DataEncoding getRecommendedEncoding() { public double getAverageSamplingPeriod() { return samplingPeriod * 60; } -} \ No newline at end of file +} diff --git a/services/sensorhub-service-oscar/src/main/java/com/botts/impl/service/oscar/webid/WebIdAnalysisException.java b/services/sensorhub-service-oscar/src/main/java/com/botts/impl/service/oscar/webid/WebIdAnalysisException.java new file mode 100644 index 00000000..35041be4 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/com/botts/impl/service/oscar/webid/WebIdAnalysisException.java @@ -0,0 +1,23 @@ +package com.botts.impl.service.oscar.webid; + +import java.io.IOException; + +public class WebIdAnalysisException extends IOException { + + private final int httpStatusCode; + private final String responseBody; + + public WebIdAnalysisException(String message, int httpStatusCode, String responseBody) { + super(message); + this.httpStatusCode = httpStatusCode; + this.responseBody = responseBody; + } + + public int getHttpStatusCode() { + return httpStatusCode; + } + + public String getResponseBody() { + return responseBody; + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/com/botts/impl/service/oscar/webid/WebIdClient.java b/services/sensorhub-service-oscar/src/main/java/com/botts/impl/service/oscar/webid/WebIdClient.java new file mode 100644 index 00000000..0dde026c --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/com/botts/impl/service/oscar/webid/WebIdClient.java @@ -0,0 +1,211 @@ +package com.botts.impl.service.oscar.webid; + +import com.google.gson.JsonArray; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import com.google.gson.JsonParser; +import org.sensorhub.impl.utils.rad.model.WebIdAnalysis; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.net.URI; +import java.net.http.HttpClient; +import java.net.http.HttpRequest; +import java.net.http.HttpResponse; +import java.nio.charset.StandardCharsets; +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import java.util.UUID; + +public class WebIdClient { + + private final HttpClient httpClient; + private final String apiRoot; + + public WebIdClient(String apiRoot) { + this.apiRoot = apiRoot.endsWith("/") ? apiRoot : apiRoot + "/"; + this.httpClient = HttpClient.newBuilder().version(HttpClient.Version.HTTP_1_1).build(); + } + + public boolean isReachable() { + try { + getPossibleDRFs(); + } catch (Exception ignored) { + return false; + } + return true; + } + + public Set getPossibleDRFs() throws IOException, InterruptedException { + HttpRequest request = HttpRequest.newBuilder() + .uri(URI.create(apiRoot + "info")) + .GET() + .build(); + + HttpResponse response = httpClient.send(request, HttpResponse.BodyHandlers.ofString()); + + JsonObject json = JsonParser.parseString(response.body()).getAsJsonObject(); + + if (!json.has("Options")) + throw new IllegalStateException("Options not found"); + + JsonArray options = json.getAsJsonArray("Options"); + + JsonObject drfOption = options.get(0).getAsJsonObject(); + + if (drfOption.has("name") && !drfOption.get("name").getAsString().equals("drf")) + throw new IllegalStateException("DRF list not found"); + + if (!drfOption.has("possibleValues")) + throw new IllegalArgumentException("possibleValues in DRF list not found"); + + JsonArray possibleValues = drfOption.getAsJsonArray("possibleValues"); + + return new HashSet<>(possibleValues.asList().stream().map(JsonElement::getAsString).toList()); + } + + public org.sensorhub.impl.utils.rad.model.WebIdAnalysis analyze(WebIdRequest webIdRequest) throws IOException, InterruptedException { + if (webIdRequest == null) { + throw new IllegalArgumentException("WebIdRequest cannot be null"); + } + + String boundary = UUID.randomUUID().toString(); + byte[] body; + try { + body = buildMultipartBody(webIdRequest, boundary); + } finally { + closeQuietly(webIdRequest.getForeground()); + closeQuietly(webIdRequest.getBackground()); + } + + StringBuilder uriBuilder = new StringBuilder(apiRoot + "analysis"); + List queryParams = new ArrayList<>(); + + if (webIdRequest.getDrf() != null && !webIdRequest.getDrf().isBlank()) { + queryParams.add("drf=" + webIdRequest.getDrf().replace(" ", "%20")); + } + if (webIdRequest.synthesizeBackground()) { + queryParams.add("synthesizeBackground=true"); + } + if (!queryParams.isEmpty()) { + uriBuilder.append("?").append(String.join("&", queryParams)); + } + + HttpRequest request = HttpRequest.newBuilder() + .uri(URI.create(uriBuilder.toString())) + .header("Content-Type", "multipart/form-data; boundary=" + boundary) + .POST(HttpRequest.BodyPublishers.ofByteArray(body)) + .build(); + + HttpResponse response = httpClient.send(request, HttpResponse.BodyHandlers.ofString()); + + if (response.statusCode() != 200) { + throw new WebIdAnalysisException("Analysis request failed with HTTP status " + response.statusCode(), + response.statusCode(), response.body()); + } + + return parseAnalysisResponse(response.body()); + } + + private void closeQuietly(InputStream stream) { + if (stream != null) { + try { + stream.close(); + } catch (IOException ignored) { + } + } + } + + private byte[] buildMultipartBody(WebIdRequest request, String boundary) throws IOException { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + + if (request.getBackground() != null) { + appendFilePart(baos, boundary, "foreground", "foreground.n42", request.getForeground()); + appendFilePart(baos, boundary, "background", "background.n42", request.getBackground()); + } else { + appendFilePart(baos, boundary, "file", "spectrum.n42", request.getForeground()); + } + + baos.write(("--" + boundary + "--\r\n").getBytes(StandardCharsets.UTF_8)); + return baos.toByteArray(); + } + + private void appendFilePart(ByteArrayOutputStream baos, String boundary, String fieldName, String fileName, InputStream inputStream) throws IOException { + if (inputStream == null) { + throw new IllegalArgumentException("InputStream for " + fieldName + " cannot be null"); + } + String partHeader = "--" + boundary + "\r\n" + + "Content-Disposition: form-data; name=\"" + fieldName + "\"; filename=\"" + fileName + "\"\r\n" + + "Content-Type: application/xml\r\n\r\n"; + baos.write(partHeader.getBytes(StandardCharsets.UTF_8)); + baos.write(inputStream.readAllBytes()); + baos.write("\r\n".getBytes(StandardCharsets.UTF_8)); + } + + private org.sensorhub.impl.utils.rad.model.WebIdAnalysis parseAnalysisResponse(String responseBody) { + JsonObject json = JsonParser.parseString(responseBody).getAsJsonObject(); + + List isotopes = new ArrayList<>(); + if (json.has("isotopes") && json.get("isotopes").isJsonArray()) { + JsonArray isotopesArray = json.getAsJsonArray("isotopes"); + for (JsonElement element : isotopesArray) { + JsonObject isotopeObj = element.getAsJsonObject(); + org.sensorhub.impl.utils.rad.model.IsotopeAnalysis isotope = new org.sensorhub.impl.utils.rad.model.IsotopeAnalysis.Builder() + .name(getStringOrNull(isotopeObj, "name")) + .type(getStringOrNull(isotopeObj, "type")) + .confidence(getFloatOrZero(isotopeObj, "confidence")) + .confidenceStr(getStringOrNull(isotopeObj, "confidenceStr")) + .countRate(getFloatOrZero(isotopeObj, "countRate")) + .build(); + isotopes.add(isotope); + } + } + + List warnings = new ArrayList<>(); + if (json.has("analysisWarnings") && json.get("analysisWarnings").isJsonArray()) { + JsonArray warningsArray = json.getAsJsonArray("analysisWarnings"); + for (JsonElement element : warningsArray) { + warnings.add(element.getAsString()); + } + } + + String errorMessage = getStringOrNull(json, "errorMessage"); + if (errorMessage == null) { + errorMessage = getStringOrNull(json, "error"); + } + + WebIdAnalysis result = new org.sensorhub.impl.utils.rad.model.WebIdAnalysis.Builder() + .isotopes(isotopes) + .estimatedDose(getDoubleOrZero(json, "estimatedDose")) + .chi2(getDoubleOrZero(json, "chi2")) + .analysisError(getIntOrZero(json, "analysisError")) + .errorMessage(errorMessage) + .analysisWarnings(warnings) + .drf(getStringOrNull(json, "drf")) + .isotopeString(getStringOrNull(json, "isotopeString")) + .build(); + + result.setRawJson(responseBody); + + return result; + } + + private String getStringOrNull(JsonObject obj, String key) { + return obj.has(key) && !obj.get(key).isJsonNull() ? obj.get(key).getAsString() : null; + } + + private float getFloatOrZero(JsonObject obj, String key) { + return obj.has(key) && !obj.get(key).isJsonNull() ? obj.get(key).getAsFloat() : 0f; + } + + private double getDoubleOrZero(JsonObject obj, String key) { + return obj.has(key) && !obj.get(key).isJsonNull() ? obj.get(key).getAsDouble() : 0d; + } + + private int getIntOrZero(JsonObject obj, String key) { + return obj.has(key) && !obj.get(key).isJsonNull() ? obj.get(key).getAsInt() : 0; + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/com/botts/impl/service/oscar/webid/WebIdRequest.java b/services/sensorhub-service-oscar/src/main/java/com/botts/impl/service/oscar/webid/WebIdRequest.java new file mode 100644 index 00000000..43f12b91 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/com/botts/impl/service/oscar/webid/WebIdRequest.java @@ -0,0 +1,112 @@ +package com.botts.impl.service.oscar.webid; + +import java.io.InputStream; +import java.net.URI; +import java.net.http.HttpClient; +import java.net.http.HttpHeaders; +import java.net.http.HttpRequest; +import java.time.Duration; +import java.util.Optional; +import java.util.Set; + +public class WebIdRequest extends HttpRequest { + + private InputStream foreground; + private InputStream background; + private String drf; + private boolean synthesizeBackground; + + private WebIdRequest() { + } + + @Override + public Optional bodyPublisher() { + return Optional.empty(); + } + + @Override + public String method() { + return "POST"; + } + + @Override + public Optional timeout() { + return Optional.empty(); + } + + @Override + public boolean expectContinue() { + return false; + } + + @Override + public URI uri() { + return null; + } + + @Override + public Optional version() { + return Optional.empty(); + } + + @Override + public HttpHeaders headers() { + return null; + } + + public InputStream getForeground() { + return foreground; + } + + public InputStream getBackground() { + return background; + } + + public String getDrf() { + return drf; + } + + public boolean synthesizeBackground() { + return synthesizeBackground; + } + + public static class Builder { + + private final WebIdRequest instance; + + public Builder() { + this.instance = new WebIdRequest(); + } + + public Builder drf(String drf) { + this.instance.drf = drf; + return Builder.this; + } + + public Builder foreground(InputStream foreground) { + this.instance.foreground = foreground; + return Builder.this; + } + + public Builder background(InputStream background) { + this.instance.background = background; + return Builder.this; + } + + public Builder synthesizeBackground(boolean synthesizeBackground) { + this.instance.synthesizeBackground = synthesizeBackground; + return Builder.this; + } + + public WebIdRequest build() { + if (this.instance.foreground == null) { + throw new IllegalStateException("Foreground spectrum is required"); + } + if (this.instance.synthesizeBackground && this.instance.background != null) { + throw new IllegalStateException("Cannot specify both synthesizeBackground=true and a background file"); + } + return this.instance; + } + } + +} diff --git a/services/sensorhub-service-oscar/src/main/java/com/botts/impl/service/oscar/webid/WebIdResourceHandler.java b/services/sensorhub-service-oscar/src/main/java/com/botts/impl/service/oscar/webid/WebIdResourceHandler.java new file mode 100644 index 00000000..c4c6de18 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/com/botts/impl/service/oscar/webid/WebIdResourceHandler.java @@ -0,0 +1,417 @@ +package com.botts.impl.service.oscar.webid; + +import com.botts.api.service.bucket.IBucketStore; +import com.botts.impl.service.bucket.handler.DefaultObjectHandler; +import com.botts.impl.service.bucket.util.MultipartRequestParser; +import com.botts.impl.service.bucket.util.RequestContext; +import com.botts.impl.service.oscar.cambio.CambioConverter; +import com.google.gson.JsonArray; +import net.opengis.swe.v20.DataBlock; +import org.sensorhub.api.common.BigId; +import org.sensorhub.api.common.IdEncoder; +import org.sensorhub.api.ISensorHub; +import org.sensorhub.api.data.ObsData; +import org.sensorhub.api.datastore.DataStoreException; +import org.sensorhub.api.datastore.obs.DataStreamFilter; +import org.sensorhub.api.utils.OshAsserts; +import org.sensorhub.impl.utils.rad.model.Occupancy; +import org.sensorhub.impl.utils.rad.model.WebIdAnalysis; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import java.io.ByteArrayInputStream; +import java.io.File; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.nio.file.Path; +import java.time.Instant; +import java.util.*; +import java.util.regex.Pattern; + +public class WebIdResourceHandler extends DefaultObjectHandler { + + private static final Logger logger = LoggerFactory.getLogger(WebIdResourceHandler.class); + private static final Set WEB_ID_FILE_EXTENSIONS = new CambioConverter().getSupportedInputFormats(); + + private static final String RADDATA_PREFIX = "RADDATA://"; + + private final Pattern pattern; + private final ISensorHub hub; + private final WebIdClient webIdClient; + private final IdEncoder obsIdEncoder; + + public WebIdResourceHandler(IBucketStore bucketStore, ISensorHub hub, WebIdClient webIdClient) { + super(bucketStore); + this.hub = hub; + this.webIdClient = webIdClient; + this.obsIdEncoder = hub.getIdEncoders().getObsIdEncoder(); + + String joinedExtensions = String.join("|", WEB_ID_FILE_EXTENSIONS); + String regex = new StringBuilder(".*\\.(") + .append(joinedExtensions) + .append(")") + .toString(); + pattern = Pattern.compile(regex); + } + + private static class WebIdRequestContext { + RequestContext parentContext; + String occupancyObsId; + String laneUid; + String drf; + boolean webIdEnabled; + boolean synthesizeBackground; + + String foregroundFileName = null; + byte[] foregroundData = null; + String backgroundFileName = null; + byte[] backgroundData = null; + + public WebIdRequestContext(RequestContext ctx) { + parentContext = ctx; + occupancyObsId = ctx.getRequest().getParameter("occupancyObsId"); + laneUid = ctx.getRequest().getParameter("laneUid"); + String webIdEnabledParam = ctx.getRequest().getParameter("webIdEnabled"); + webIdEnabled = Boolean.parseBoolean(webIdEnabledParam); + drf = ctx.getRequest().getParameter("drf"); + String synthesizeBackgroundParam = ctx.getRequest().getParameter("synthesizeBackground"); + synthesizeBackground = Boolean.parseBoolean(synthesizeBackgroundParam); + + if (ctx.isMultipartRequest()) { + try (var parseResult = MultipartRequestParser.parse(ctx.getRequest())) { + + for (var file : parseResult.files()) { + String fileName = file.fileName(); + String fieldName = file.fieldName(); + + if ("foreground".equals(fieldName)) { + foregroundFileName = fileName; + try (var fileStream = file.inputStream()) { + foregroundData = fileStream.readAllBytes(); + } + } else if ("background".equals(fieldName)) { + backgroundFileName = fileName; + try (var fileStream = file.inputStream()) { + backgroundData = fileStream.readAllBytes(); + } + } + } + } catch (IOException e) { + logger.error("Unable to parse multipart data", e); + } + } else { + try (var contextInputStream = ctx.getRequest().getInputStream()) { + foregroundData = contextInputStream.readAllBytes(); + if (ctx.hasObjectKey()) + foregroundFileName = ctx.getObjectKey(); + } catch (IOException e) { + logger.error("Unable to retrieve request context input stream", e); + } + } + } + + public boolean hasForegroundFileName() { + return foregroundFileName != null && !foregroundFileName.isBlank(); + } + + public boolean hasBackgroundFileName() { + return backgroundFileName != null && !backgroundFileName.isBlank(); + } + } + + @Override + public void doPut(RequestContext ctx) throws IOException, SecurityException { + var bucketName = ctx.getBucketName(); + var objectKey = ctx.getObjectKey(); + var sec = ctx.getSecurityHandler(); + sec.checkPermission(sec.getBucketPermission(bucketName).put); + + // Extract query parameters + var webIdContext = new WebIdRequestContext(ctx); + + if (!webIdContext.webIdEnabled) + return; + + // PUT should only update one resource, so prioritize POST for FG + BG + if (webIdContext.foregroundData != null && webIdContext.hasForegroundFileName()) { + // Update the object in the bucket + try { + bucketStore.putObject(bucketName, objectKey, new ByteArrayInputStream(webIdContext.foregroundData), ctx.getHeaders()); + } catch (DataStoreException e) { + throw new IOException(IBucketStore.FAILED_PUT_OBJECT + bucketName, e); + } + } + + ctx.getResponse().setStatus(HttpServletResponse.SC_OK); + + // Check if web ID is reachable + if (webIdClient != null && webIdClient.isReachable()) { + processWebIdAnalysis(webIdContext); + } else { + // offline conversion to N42 only +// processCambioConversion(webIdContext); + } + } + + @Override + public void doPost(RequestContext ctx) throws IOException, SecurityException { + var bucketName = ctx.getBucketName(); + var sec = ctx.getSecurityHandler(); + sec.checkPermission(sec.getBucketPermission(bucketName).create); + + // Extract query parameters + var webIdContext = new WebIdRequestContext(ctx); + + if (!webIdContext.webIdEnabled) + return; + + List resourceURIs = new ArrayList<>(); + + // Save background data in bucket + if (webIdContext.backgroundData != null + // ensure we have a filename for put requests + && webIdContext.backgroundFileName != null + && !webIdContext.backgroundFileName.isBlank()) { + try { + bucketStore.putObject(bucketName, webIdContext.backgroundFileName, + new ByteArrayInputStream(webIdContext.backgroundData), ctx.getHeaders()); + // add to generated resource URI list + resourceURIs.add(bucketStore.getRelativeResourceURI(bucketName, webIdContext.backgroundFileName)); + } catch (DataStoreException e) { + logger.error("Failed to put background data from {} in bucket store", webIdContext.backgroundFileName, e); + } + } + + // For POST, we can have foreground data with no filename (i.e. QR code) + if (webIdContext.foregroundData != null) { + try { + // put if foreground + background + if (webIdContext.hasForegroundFileName()) { + bucketStore.putObject(bucketName, webIdContext.foregroundFileName, + new ByteArrayInputStream(webIdContext.foregroundData), ctx.getHeaders()); + // add to generated resource URI list + resourceURIs.add(bucketStore.getRelativeResourceURI(bucketName, webIdContext.foregroundFileName)); + } else { + // create object with random UUID if just foreground data + String newObjectKey = bucketStore.createObject(bucketName, + new ByteArrayInputStream(webIdContext.foregroundData), ctx.getHeaders()); + if (newObjectKey == null || newObjectKey.isBlank()) + throw new IOException(IBucketStore.FAILED_CREATE_OBJECT + bucketName); + + // set location header for single resource + ctx.getResponse().setHeader("Location", bucketStore.getRelativeResourceURI(bucketName, newObjectKey)); + } + ctx.getResponse().setStatus(HttpServletResponse.SC_CREATED); + } catch (Exception e) { + throw new IOException("Failed to put foreground data in bucket store", e); + } + } + + if (!resourceURIs.isEmpty()) { + JsonArray jsonArray = new JsonArray(); + for (var resourceURI : resourceURIs) + jsonArray.add(resourceURI); + ctx.getResponse().getWriter().write(jsonArray.toString()); + } + + // Check if web ID is reachable + if (webIdClient != null && webIdClient.isReachable()) { + processWebIdAnalysis(webIdContext); + } else { + // offline conversion to N42 only +// processCambioConversion(webIdContext); + } + } + + private void processCambioConversion(WebIdRequestContext webIdContext) { + // TODO make sure nothing special required for cambio conversion + } + + private void processWebIdAnalysis(WebIdRequestContext webIdContext) { + try { + if (webIdContext.foregroundData == null) + throw new IllegalArgumentException("Foreground data is null"); + + // Check if this is QR code data (RADDATA:// format) + boolean isQrCodeData = isRadDataQrCode(webIdContext.foregroundData); + + WebIdAnalysis analysis; + // Try sending to WebID first with raw data + try { + var request = createWebIdRequest(webIdContext); + analysis = webIdClient.analyze(request); + logger.info("WebID analysis succeeded with raw data"); + } catch (Exception e) { + // If QR code data failed, don't try Cambio conversion - just rethrow + if (isQrCodeData) + throw new IOException("WebID analysis failed for QR code data", e); + + // For other formats, try converting to N42 via Cambio and retry + logger.info("WebID analysis failed with raw data, attempting Cambio conversion: {}", e.getMessage()); + + byte[] n42Bytes; + if (webIdContext.hasForegroundFileName() && (webIdContext.foregroundFileName.endsWith(".n42") + || webIdContext.foregroundFileName.endsWith(".xml"))) { + n42Bytes = webIdContext.foregroundData; + } else { + String fileName; + if (webIdContext.foregroundFileName != null && !webIdContext.foregroundFileName.isBlank()) { + fileName = webIdContext.foregroundFileName; + } else { + fileName = UUID.randomUUID() + ".n42"; + } + n42Bytes = new CambioConverter().convertToN42(new ByteArrayInputStream(webIdContext.foregroundData), fileName); + } + + WebIdRequest.Builder requestBuilder = new WebIdRequest.Builder() + .foreground(new ByteArrayInputStream(n42Bytes)) + .drf(webIdContext.drf); + + if (webIdContext.backgroundData != null) + requestBuilder.background(new ByteArrayInputStream(webIdContext.backgroundData)); + + // client chooses whether to synthesize background data + requestBuilder.synthesizeBackground(webIdContext.synthesizeBackground); + + analysis = webIdClient.analyze(requestBuilder.build()); + logger.info("WebID analysis succeeded after Cambio conversion"); + } + + analysis.setSampleTime(Instant.now()); + analysis.setOccupancyObsId(webIdContext.occupancyObsId != null ? webIdContext.occupancyObsId : ""); + + // Save analysis JSON to bucket store + try { + String analysisJson = analysis.toString(); + Map jsonMetadata = new HashMap<>(); + jsonMetadata.put("Content-Type", "application/json"); + bucketStore.createObject(webIdContext.parentContext.getBucketName(), new ByteArrayInputStream(analysisJson.getBytes()), jsonMetadata); + } catch (DataStoreException e) { + logger.error("Failed to store WebId analysis JSON in bucket", e); + } + + // Insert WebId observation into lane database + String encodedWebIdObsId = null; + if (webIdContext.laneUid != null && !webIdContext.laneUid.isBlank()) { + try { + var laneDb = hub.getSystemDriverRegistry().getDatabase(webIdContext.laneUid); + if (laneDb == null) { + logger.error("No database found for lane UID: {}", webIdContext.laneUid); + return; + } + + var obsStore = laneDb.getObservationStore(); + + // Find the WebId datastream + var dsKeys = obsStore.getDataStreams().selectKeys(new DataStreamFilter.Builder() + .withSystems() + .withUniqueIDs(webIdContext.laneUid) + .done() + .withOutputNames("webIdAnalysis") + .build()).toList(); + + if (dsKeys.isEmpty()) { + logger.error("No webIdAnalysis datastream found for lane: {}", webIdContext.laneUid); + return; + } + + var dsId = dsKeys.get(0).getInternalID(); + + // Create DataBlock from analysis + DataBlock webIdDataBlock = WebIdAnalysis.fromWebIdAnalysis(analysis); + + // Insert observation + var obsId = obsStore.add(new ObsData.Builder() + .withDataStream(dsId) + .withPhenomenonTime(Instant.now()) + .withResultTime(Instant.now()) + .withResult(webIdDataBlock) + .build()); + + encodedWebIdObsId = obsIdEncoder.encodeID(obsId); + logger.info("WebId analysis observation stored with ID: {}", encodedWebIdObsId); + } catch (Exception e) { + logger.error("Failed to insert WebId observation into lane database", e); + } + } + + // Attach WebId obs ID to occupancy observation + if (encodedWebIdObsId != null && webIdContext.occupancyObsId != null && !webIdContext.occupancyObsId.isBlank() && webIdContext.laneUid != null) { + try { + BigId decodedOccObsId = obsIdEncoder.decodeID(webIdContext.occupancyObsId); + var laneDb = hub.getSystemDriverRegistry().getDatabase(webIdContext.laneUid); + if (laneDb == null) { + logger.error("No database found for lane UID when updating occupancy: {}", webIdContext.laneUid); + return; + } + + var obsStore = laneDb.getObservationStore(); + var obs = obsStore.get(decodedOccObsId); + if (obs == null) { + logger.error("Occupancy observation not found for ID: {}", webIdContext.occupancyObsId); + return; + } + + var occupancy = Occupancy.toOccupancy(obs.getResult()); + occupancy.addWebIdObsId(encodedWebIdObsId); + + DataBlock newOccupancyResult = Occupancy.fromOccupancy(occupancy); + obs.getResult().setUnderlyingObject(newOccupancyResult.getUnderlyingObject()); + obs.getResult().updateAtomCount(); + + obsStore.put(decodedOccObsId, obs); + logger.info("Occupancy observation {} updated with WebId obs ID: {}", webIdContext.occupancyObsId, encodedWebIdObsId); + } catch (Exception e) { + logger.error("Failed to update occupancy observation with WebId obs ID", e); + } + } + } catch (Exception e) { + logger.error("WebId analysis processing failed", e); + } + } + + private WebIdRequest createWebIdRequest(WebIdRequestContext webIdContext) { + WebIdRequest.Builder requestBuilder = new WebIdRequest.Builder() + .foreground(new ByteArrayInputStream(webIdContext.foregroundData)); + + // include background but if no background data then we need to synthesize it + if (webIdContext.backgroundData != null) + requestBuilder.background(new ByteArrayInputStream(webIdContext.backgroundData)); + + // client chooses whether to synthesize background data + requestBuilder.synthesizeBackground(webIdContext.synthesizeBackground); + + if (webIdContext.drf != null && !webIdContext.drf.isBlank()) + requestBuilder.drf(webIdContext.drf); + + return requestBuilder.build(); + } + + /** + * Checks if the data is QR code data in RADDATA:// format. + */ + private boolean isRadDataQrCode(byte[] data) { + if (data == null || data.length < RADDATA_PREFIX.length()) { + return false; + } + String prefix = new String(data, 0, RADDATA_PREFIX.length(), StandardCharsets.UTF_8); + return RADDATA_PREFIX.equals(prefix); + } + + /** + * Returns true if this handler should handle the request based on the webIdEnabled query parameter. + * This allows QR code data to be POSTed directly to the bucket root without specifying a filename. + */ + @Override + public boolean canHandleRequest(HttpServletRequest request) { + String webIdEnabledParam = request.getParameter("webIdEnabled"); + return Boolean.parseBoolean(webIdEnabledParam); + } + + @Override + public String getObjectPattern() { + return this.pattern.pattern(); + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/D3SpectrumChartOptions.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/D3SpectrumChartOptions.java new file mode 100644 index 00000000..ad8ca503 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/D3SpectrumChartOptions.java @@ -0,0 +1,236 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class D3SpectrumChartOptions { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected D3SpectrumChartOptions(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(D3SpectrumChartOptions obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(D3SpectrumChartOptions obj) { + long ptr = 0; + if (obj != null) { + if (!obj.swigCMemOwn) + throw new RuntimeException("Cannot release ownership as memory is not owned"); + ptr = obj.swigCPtr; + obj.swigCMemOwn = false; + obj.delete(); + } + return ptr; + } + + @SuppressWarnings({"deprecation", "removal"}) + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + SpecUtilsSwigJNI.delete_D3SpectrumChartOptions(swigCPtr); + } + swigCPtr = 0; + } + } + + public D3SpectrumChartOptions() { + this(SpecUtilsSwigJNI.new_D3SpectrumChartOptions__SWIG_0(), true); + } + + public D3SpectrumChartOptions(String title, String xAxisTitle, String yAxisTitle, String dataTitle, boolean useLogYAxis, boolean showVerticalGridLines, boolean showHorizontalGridLines, boolean legendEnabled, boolean compactXAxis, boolean showPeakUserLabels, boolean showPeakEnergyLabels, boolean showPeakNuclideLabels, boolean showPeakNuclideEnergyLabels, boolean showEscapePeakMarker, boolean showComptonPeakMarker, boolean showComptonEdgeMarker, boolean showSumPeakMarker, boolean backgroundSubtract, float xMin, float xMax, SWIGTYPE_p_std__mapT_std__string_std__string_t refernce_lines_json) { + this(SpecUtilsSwigJNI.new_D3SpectrumChartOptions__SWIG_1(title, xAxisTitle, yAxisTitle, dataTitle, useLogYAxis, showVerticalGridLines, showHorizontalGridLines, legendEnabled, compactXAxis, showPeakUserLabels, showPeakEnergyLabels, showPeakNuclideLabels, showPeakNuclideEnergyLabels, showEscapePeakMarker, showComptonPeakMarker, showComptonEdgeMarker, showSumPeakMarker, backgroundSubtract, xMin, xMax, SWIGTYPE_p_std__mapT_std__string_std__string_t.getCPtr(refernce_lines_json)), true); + } + + public void setM_title(String value) { + SpecUtilsSwigJNI.D3SpectrumChartOptions_m_title_set(swigCPtr, this, value); + } + + public String getM_title() { + return SpecUtilsSwigJNI.D3SpectrumChartOptions_m_title_get(swigCPtr, this); + } + + public void setM_xAxisTitle(String value) { + SpecUtilsSwigJNI.D3SpectrumChartOptions_m_xAxisTitle_set(swigCPtr, this, value); + } + + public String getM_xAxisTitle() { + return SpecUtilsSwigJNI.D3SpectrumChartOptions_m_xAxisTitle_get(swigCPtr, this); + } + + public void setM_yAxisTitle(String value) { + SpecUtilsSwigJNI.D3SpectrumChartOptions_m_yAxisTitle_set(swigCPtr, this, value); + } + + public String getM_yAxisTitle() { + return SpecUtilsSwigJNI.D3SpectrumChartOptions_m_yAxisTitle_get(swigCPtr, this); + } + + public void setM_dataTitle(String value) { + SpecUtilsSwigJNI.D3SpectrumChartOptions_m_dataTitle_set(swigCPtr, this, value); + } + + public String getM_dataTitle() { + return SpecUtilsSwigJNI.D3SpectrumChartOptions_m_dataTitle_get(swigCPtr, this); + } + + public void setM_useLogYAxis(boolean value) { + SpecUtilsSwigJNI.D3SpectrumChartOptions_m_useLogYAxis_set(swigCPtr, this, value); + } + + public boolean getM_useLogYAxis() { + return SpecUtilsSwigJNI.D3SpectrumChartOptions_m_useLogYAxis_get(swigCPtr, this); + } + + public void setM_showVerticalGridLines(boolean value) { + SpecUtilsSwigJNI.D3SpectrumChartOptions_m_showVerticalGridLines_set(swigCPtr, this, value); + } + + public boolean getM_showVerticalGridLines() { + return SpecUtilsSwigJNI.D3SpectrumChartOptions_m_showVerticalGridLines_get(swigCPtr, this); + } + + public void setM_showHorizontalGridLines(boolean value) { + SpecUtilsSwigJNI.D3SpectrumChartOptions_m_showHorizontalGridLines_set(swigCPtr, this, value); + } + + public boolean getM_showHorizontalGridLines() { + return SpecUtilsSwigJNI.D3SpectrumChartOptions_m_showHorizontalGridLines_get(swigCPtr, this); + } + + public void setM_legendEnabled(boolean value) { + SpecUtilsSwigJNI.D3SpectrumChartOptions_m_legendEnabled_set(swigCPtr, this, value); + } + + public boolean getM_legendEnabled() { + return SpecUtilsSwigJNI.D3SpectrumChartOptions_m_legendEnabled_get(swigCPtr, this); + } + + public void setM_compactXAxis(boolean value) { + SpecUtilsSwigJNI.D3SpectrumChartOptions_m_compactXAxis_set(swigCPtr, this, value); + } + + public boolean getM_compactXAxis() { + return SpecUtilsSwigJNI.D3SpectrumChartOptions_m_compactXAxis_get(swigCPtr, this); + } + + public void setM_showPeakUserLabels(boolean value) { + SpecUtilsSwigJNI.D3SpectrumChartOptions_m_showPeakUserLabels_set(swigCPtr, this, value); + } + + public boolean getM_showPeakUserLabels() { + return SpecUtilsSwigJNI.D3SpectrumChartOptions_m_showPeakUserLabels_get(swigCPtr, this); + } + + public void setM_showPeakEnergyLabels(boolean value) { + SpecUtilsSwigJNI.D3SpectrumChartOptions_m_showPeakEnergyLabels_set(swigCPtr, this, value); + } + + public boolean getM_showPeakEnergyLabels() { + return SpecUtilsSwigJNI.D3SpectrumChartOptions_m_showPeakEnergyLabels_get(swigCPtr, this); + } + + public void setM_showPeakNuclideLabels(boolean value) { + SpecUtilsSwigJNI.D3SpectrumChartOptions_m_showPeakNuclideLabels_set(swigCPtr, this, value); + } + + public boolean getM_showPeakNuclideLabels() { + return SpecUtilsSwigJNI.D3SpectrumChartOptions_m_showPeakNuclideLabels_get(swigCPtr, this); + } + + public void setM_showPeakNuclideEnergyLabels(boolean value) { + SpecUtilsSwigJNI.D3SpectrumChartOptions_m_showPeakNuclideEnergyLabels_set(swigCPtr, this, value); + } + + public boolean getM_showPeakNuclideEnergyLabels() { + return SpecUtilsSwigJNI.D3SpectrumChartOptions_m_showPeakNuclideEnergyLabels_get(swigCPtr, this); + } + + public void setM_showEscapePeakMarker(boolean value) { + SpecUtilsSwigJNI.D3SpectrumChartOptions_m_showEscapePeakMarker_set(swigCPtr, this, value); + } + + public boolean getM_showEscapePeakMarker() { + return SpecUtilsSwigJNI.D3SpectrumChartOptions_m_showEscapePeakMarker_get(swigCPtr, this); + } + + public void setM_showComptonPeakMarker(boolean value) { + SpecUtilsSwigJNI.D3SpectrumChartOptions_m_showComptonPeakMarker_set(swigCPtr, this, value); + } + + public boolean getM_showComptonPeakMarker() { + return SpecUtilsSwigJNI.D3SpectrumChartOptions_m_showComptonPeakMarker_get(swigCPtr, this); + } + + public void setM_showComptonEdgeMarker(boolean value) { + SpecUtilsSwigJNI.D3SpectrumChartOptions_m_showComptonEdgeMarker_set(swigCPtr, this, value); + } + + public boolean getM_showComptonEdgeMarker() { + return SpecUtilsSwigJNI.D3SpectrumChartOptions_m_showComptonEdgeMarker_get(swigCPtr, this); + } + + public void setM_showSumPeakMarker(boolean value) { + SpecUtilsSwigJNI.D3SpectrumChartOptions_m_showSumPeakMarker_set(swigCPtr, this, value); + } + + public boolean getM_showSumPeakMarker() { + return SpecUtilsSwigJNI.D3SpectrumChartOptions_m_showSumPeakMarker_get(swigCPtr, this); + } + + public void setM_backgroundSubtract(boolean value) { + SpecUtilsSwigJNI.D3SpectrumChartOptions_m_backgroundSubtract_set(swigCPtr, this, value); + } + + public boolean getM_backgroundSubtract() { + return SpecUtilsSwigJNI.D3SpectrumChartOptions_m_backgroundSubtract_get(swigCPtr, this); + } + + public void setM_allowDragRoiExtent(boolean value) { + SpecUtilsSwigJNI.D3SpectrumChartOptions_m_allowDragRoiExtent_set(swigCPtr, this, value); + } + + public boolean getM_allowDragRoiExtent() { + return SpecUtilsSwigJNI.D3SpectrumChartOptions_m_allowDragRoiExtent_get(swigCPtr, this); + } + + public void setM_xMin(float value) { + SpecUtilsSwigJNI.D3SpectrumChartOptions_m_xMin_set(swigCPtr, this, value); + } + + public float getM_xMin() { + return SpecUtilsSwigJNI.D3SpectrumChartOptions_m_xMin_get(swigCPtr, this); + } + + public void setM_xMax(float value) { + SpecUtilsSwigJNI.D3SpectrumChartOptions_m_xMax_set(swigCPtr, this, value); + } + + public float getM_xMax() { + return SpecUtilsSwigJNI.D3SpectrumChartOptions_m_xMax_get(swigCPtr, this); + } + + public void setM_reference_lines_json(SWIGTYPE_p_std__mapT_std__string_std__string_t value) { + SpecUtilsSwigJNI.D3SpectrumChartOptions_m_reference_lines_json_set(swigCPtr, this, SWIGTYPE_p_std__mapT_std__string_std__string_t.getCPtr(value)); + } + + public SWIGTYPE_p_std__mapT_std__string_std__string_t getM_reference_lines_json() { + long cPtr = SpecUtilsSwigJNI.D3SpectrumChartOptions_m_reference_lines_json_get(swigCPtr, this); + return (cPtr == 0) ? null : new SWIGTYPE_p_std__mapT_std__string_std__string_t(cPtr, false); + } + +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/D3SpectrumOptions.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/D3SpectrumOptions.java new file mode 100644 index 00000000..da50b77b --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/D3SpectrumOptions.java @@ -0,0 +1,103 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class D3SpectrumOptions { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected D3SpectrumOptions(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(D3SpectrumOptions obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(D3SpectrumOptions obj) { + long ptr = 0; + if (obj != null) { + if (!obj.swigCMemOwn) + throw new RuntimeException("Cannot release ownership as memory is not owned"); + ptr = obj.swigCPtr; + obj.swigCMemOwn = false; + obj.delete(); + } + return ptr; + } + + @SuppressWarnings({"deprecation", "removal"}) + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + SpecUtilsSwigJNI.delete_D3SpectrumOptions(swigCPtr); + } + swigCPtr = 0; + } + } + + public D3SpectrumOptions() { + this(SpecUtilsSwigJNI.new_D3SpectrumOptions(), true); + } + + public void setPeaks_json(String value) { + SpecUtilsSwigJNI.D3SpectrumOptions_peaks_json_set(swigCPtr, this, value); + } + + public String getPeaks_json() { + return SpecUtilsSwigJNI.D3SpectrumOptions_peaks_json_get(swigCPtr, this); + } + + public void setLine_color(String value) { + SpecUtilsSwigJNI.D3SpectrumOptions_line_color_set(swigCPtr, this, value); + } + + public String getLine_color() { + return SpecUtilsSwigJNI.D3SpectrumOptions_line_color_get(swigCPtr, this); + } + + public void setPeak_color(String value) { + SpecUtilsSwigJNI.D3SpectrumOptions_peak_color_set(swigCPtr, this, value); + } + + public String getPeak_color() { + return SpecUtilsSwigJNI.D3SpectrumOptions_peak_color_get(swigCPtr, this); + } + + public void setTitle(String value) { + SpecUtilsSwigJNI.D3SpectrumOptions_title_set(swigCPtr, this, value); + } + + public String getTitle() { + return SpecUtilsSwigJNI.D3SpectrumOptions_title_get(swigCPtr, this); + } + + public void setDisplay_scale_factor(double value) { + SpecUtilsSwigJNI.D3SpectrumOptions_display_scale_factor_set(swigCPtr, this, value); + } + + public double getDisplay_scale_factor() { + return SpecUtilsSwigJNI.D3SpectrumOptions_display_scale_factor_get(swigCPtr, this); + } + + public void setSpectrum_type(SpectrumType value) { + SpecUtilsSwigJNI.D3SpectrumOptions_spectrum_type_set(swigCPtr, this, value.swigValue()); + } + + public SpectrumType getSpectrum_type() { + return SpectrumType.swigToEnum(SpecUtilsSwigJNI.D3SpectrumOptions_spectrum_type_get(swigCPtr, this)); + } + +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/DetectorAnalysis.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/DetectorAnalysis.java new file mode 100644 index 00000000..7e060939 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/DetectorAnalysis.java @@ -0,0 +1,138 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class DetectorAnalysis { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected DetectorAnalysis(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(DetectorAnalysis obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(DetectorAnalysis obj) { + long ptr = 0; + if (obj != null) { + if (!obj.swigCMemOwn) + throw new RuntimeException("Cannot release ownership as memory is not owned"); + ptr = obj.swigCPtr; + obj.swigCMemOwn = false; + obj.delete(); + } + return ptr; + } + + @SuppressWarnings({"deprecation", "removal"}) + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + SpecUtilsSwigJNI.delete_DetectorAnalysis(swigCPtr); + } + swigCPtr = 0; + } + } + + public void setRemarks_(StringVector value) { + SpecUtilsSwigJNI.DetectorAnalysis_remarks__set(swigCPtr, this, StringVector.getCPtr(value), value); + } + + public StringVector getRemarks_() { + long cPtr = SpecUtilsSwigJNI.DetectorAnalysis_remarks__get(swigCPtr, this); + return (cPtr == 0) ? null : new StringVector(cPtr, false); + } + + public void setAlgorithm_name_(String value) { + SpecUtilsSwigJNI.DetectorAnalysis_algorithm_name__set(swigCPtr, this, value); + } + + public String getAlgorithm_name_() { + return SpecUtilsSwigJNI.DetectorAnalysis_algorithm_name__get(swigCPtr, this); + } + + public void setAlgorithm_component_versions_(SWIGTYPE_p_std__vectorT_std__pairT_std__string_std__string_t_t value) { + SpecUtilsSwigJNI.DetectorAnalysis_algorithm_component_versions__set(swigCPtr, this, SWIGTYPE_p_std__vectorT_std__pairT_std__string_std__string_t_t.getCPtr(value)); + } + + public SWIGTYPE_p_std__vectorT_std__pairT_std__string_std__string_t_t getAlgorithm_component_versions_() { + long cPtr = SpecUtilsSwigJNI.DetectorAnalysis_algorithm_component_versions__get(swigCPtr, this); + return (cPtr == 0) ? null : new SWIGTYPE_p_std__vectorT_std__pairT_std__string_std__string_t_t(cPtr, false); + } + + public void setAlgorithm_creator_(String value) { + SpecUtilsSwigJNI.DetectorAnalysis_algorithm_creator__set(swigCPtr, this, value); + } + + public String getAlgorithm_creator_() { + return SpecUtilsSwigJNI.DetectorAnalysis_algorithm_creator__get(swigCPtr, this); + } + + public void setAlgorithm_description_(String value) { + SpecUtilsSwigJNI.DetectorAnalysis_algorithm_description__set(swigCPtr, this, value); + } + + public String getAlgorithm_description_() { + return SpecUtilsSwigJNI.DetectorAnalysis_algorithm_description__get(swigCPtr, this); + } + + public void setAnalysis_start_time_(SWIGTYPE_p_std__chrono__time_pointT_std__chrono__system_clock_std__chrono__microseconds_t value) { + SpecUtilsSwigJNI.DetectorAnalysis_analysis_start_time__set(swigCPtr, this, SWIGTYPE_p_std__chrono__time_pointT_std__chrono__system_clock_std__chrono__microseconds_t.getCPtr(value)); + } + + public SWIGTYPE_p_std__chrono__time_pointT_std__chrono__system_clock_std__chrono__microseconds_t getAnalysis_start_time_() { + return new SWIGTYPE_p_std__chrono__time_pointT_std__chrono__system_clock_std__chrono__microseconds_t(SpecUtilsSwigJNI.DetectorAnalysis_analysis_start_time__get(swigCPtr, this), true); + } + + public void setAnalysis_computation_duration_(float value) { + SpecUtilsSwigJNI.DetectorAnalysis_analysis_computation_duration__set(swigCPtr, this, value); + } + + public float getAnalysis_computation_duration_() { + return SpecUtilsSwigJNI.DetectorAnalysis_analysis_computation_duration__get(swigCPtr, this); + } + + public void setAlgorithm_result_description_(String value) { + SpecUtilsSwigJNI.DetectorAnalysis_algorithm_result_description__set(swigCPtr, this, value); + } + + public String getAlgorithm_result_description_() { + return SpecUtilsSwigJNI.DetectorAnalysis_algorithm_result_description__get(swigCPtr, this); + } + + public void setResults_(SWIGTYPE_p_std__vectorT_SpecUtils__DetectorAnalysisResult_t value) { + SpecUtilsSwigJNI.DetectorAnalysis_results__set(swigCPtr, this, SWIGTYPE_p_std__vectorT_SpecUtils__DetectorAnalysisResult_t.getCPtr(value)); + } + + public SWIGTYPE_p_std__vectorT_SpecUtils__DetectorAnalysisResult_t getResults_() { + long cPtr = SpecUtilsSwigJNI.DetectorAnalysis_results__get(swigCPtr, this); + return (cPtr == 0) ? null : new SWIGTYPE_p_std__vectorT_SpecUtils__DetectorAnalysisResult_t(cPtr, false); + } + + public DetectorAnalysis() { + this(SpecUtilsSwigJNI.new_DetectorAnalysis(), true); + } + + public void reset() { + SpecUtilsSwigJNI.DetectorAnalysis_reset(swigCPtr, this); + } + + public boolean is_empty() { + return SpecUtilsSwigJNI.DetectorAnalysis_is_empty(swigCPtr, this); + } + +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/DetectorAnalysisResult.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/DetectorAnalysisResult.java new file mode 100644 index 00000000..7a38e24c --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/DetectorAnalysisResult.java @@ -0,0 +1,135 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class DetectorAnalysisResult { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected DetectorAnalysisResult(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(DetectorAnalysisResult obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(DetectorAnalysisResult obj) { + long ptr = 0; + if (obj != null) { + if (!obj.swigCMemOwn) + throw new RuntimeException("Cannot release ownership as memory is not owned"); + ptr = obj.swigCPtr; + obj.swigCMemOwn = false; + obj.delete(); + } + return ptr; + } + + @SuppressWarnings({"deprecation", "removal"}) + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + SpecUtilsSwigJNI.delete_DetectorAnalysisResult(swigCPtr); + } + swigCPtr = 0; + } + } + + public void setRemark_(String value) { + SpecUtilsSwigJNI.DetectorAnalysisResult_remark__set(swigCPtr, this, value); + } + + public String getRemark_() { + return SpecUtilsSwigJNI.DetectorAnalysisResult_remark__get(swigCPtr, this); + } + + public void setNuclide_(String value) { + SpecUtilsSwigJNI.DetectorAnalysisResult_nuclide__set(swigCPtr, this, value); + } + + public String getNuclide_() { + return SpecUtilsSwigJNI.DetectorAnalysisResult_nuclide__get(swigCPtr, this); + } + + public void setActivity_(float value) { + SpecUtilsSwigJNI.DetectorAnalysisResult_activity__set(swigCPtr, this, value); + } + + public float getActivity_() { + return SpecUtilsSwigJNI.DetectorAnalysisResult_activity__get(swigCPtr, this); + } + + public void setNuclide_type_(String value) { + SpecUtilsSwigJNI.DetectorAnalysisResult_nuclide_type__set(swigCPtr, this, value); + } + + public String getNuclide_type_() { + return SpecUtilsSwigJNI.DetectorAnalysisResult_nuclide_type__get(swigCPtr, this); + } + + public void setId_confidence_(String value) { + SpecUtilsSwigJNI.DetectorAnalysisResult_id_confidence__set(swigCPtr, this, value); + } + + public String getId_confidence_() { + return SpecUtilsSwigJNI.DetectorAnalysisResult_id_confidence__get(swigCPtr, this); + } + + public void setDistance_(float value) { + SpecUtilsSwigJNI.DetectorAnalysisResult_distance__set(swigCPtr, this, value); + } + + public float getDistance_() { + return SpecUtilsSwigJNI.DetectorAnalysisResult_distance__get(swigCPtr, this); + } + + public void setDose_rate_(float value) { + SpecUtilsSwigJNI.DetectorAnalysisResult_dose_rate__set(swigCPtr, this, value); + } + + public float getDose_rate_() { + return SpecUtilsSwigJNI.DetectorAnalysisResult_dose_rate__get(swigCPtr, this); + } + + public void setReal_time_(float value) { + SpecUtilsSwigJNI.DetectorAnalysisResult_real_time__set(swigCPtr, this, value); + } + + public float getReal_time_() { + return SpecUtilsSwigJNI.DetectorAnalysisResult_real_time__get(swigCPtr, this); + } + + public void setDetector_(String value) { + SpecUtilsSwigJNI.DetectorAnalysisResult_detector__set(swigCPtr, this, value); + } + + public String getDetector_() { + return SpecUtilsSwigJNI.DetectorAnalysisResult_detector__get(swigCPtr, this); + } + + public DetectorAnalysisResult() { + this(SpecUtilsSwigJNI.new_DetectorAnalysisResult(), true); + } + + public void reset() { + SpecUtilsSwigJNI.DetectorAnalysisResult_reset(swigCPtr, this); + } + + public boolean isEmpty() { + return SpecUtilsSwigJNI.DetectorAnalysisResult_isEmpty(swigCPtr, this); + } + +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/DetectorType.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/DetectorType.java new file mode 100644 index 00000000..d57ee2d0 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/DetectorType.java @@ -0,0 +1,96 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public final class DetectorType { + public final static DetectorType Exploranium = new DetectorType("Exploranium"); + public final static DetectorType IdentiFinder = new DetectorType("IdentiFinder"); + public final static DetectorType IdentiFinderNG = new DetectorType("IdentiFinderNG"); + public final static DetectorType IdentiFinderLaBr3 = new DetectorType("IdentiFinderLaBr3"); + public final static DetectorType IdentiFinderTungsten = new DetectorType("IdentiFinderTungsten"); + public final static DetectorType IdentiFinderR425NaI = new DetectorType("IdentiFinderR425NaI"); + public final static DetectorType IdentiFinderR425LaBr = new DetectorType("IdentiFinderR425LaBr"); + public final static DetectorType IdentiFinderR500NaI = new DetectorType("IdentiFinderR500NaI"); + public final static DetectorType IdentiFinderR500LaBr = new DetectorType("IdentiFinderR500LaBr"); + public final static DetectorType IdentiFinderUnknown = new DetectorType("IdentiFinderUnknown"); + public final static DetectorType DetectiveUnknown = new DetectorType("DetectiveUnknown"); + public final static DetectorType DetectiveEx = new DetectorType("DetectiveEx"); + public final static DetectorType DetectiveEx100 = new DetectorType("DetectiveEx100"); + public final static DetectorType DetectiveEx200 = new DetectorType("DetectiveEx200"); + public final static DetectorType DetectiveX = new DetectorType("DetectiveX"); + public final static DetectorType SAIC8 = new DetectorType("SAIC8"); + public final static DetectorType Falcon5000 = new DetectorType("Falcon5000"); + public final static DetectorType MicroDetective = new DetectorType("MicroDetective"); + public final static DetectorType MicroRaider = new DetectorType("MicroRaider"); + public final static DetectorType RadiaCode = new DetectorType("RadiaCode"); + public final static DetectorType Interceptor = new DetectorType("Interceptor"); + public final static DetectorType RadHunterNaI = new DetectorType("RadHunterNaI"); + public final static DetectorType RadHunterLaBr3 = new DetectorType("RadHunterLaBr3"); + public final static DetectorType Rsi701 = new DetectorType("Rsi701"); + public final static DetectorType Rsi705 = new DetectorType("Rsi705"); + public final static DetectorType AvidRsi = new DetectorType("AvidRsi"); + public final static DetectorType OrtecRadEagleNai = new DetectorType("OrtecRadEagleNai"); + public final static DetectorType OrtecRadEagleCeBr2Inch = new DetectorType("OrtecRadEagleCeBr2Inch"); + public final static DetectorType OrtecRadEagleCeBr3Inch = new DetectorType("OrtecRadEagleCeBr3Inch"); + public final static DetectorType OrtecRadEagleLaBr = new DetectorType("OrtecRadEagleLaBr"); + public final static DetectorType Sam940LaBr3 = new DetectorType("Sam940LaBr3"); + public final static DetectorType Sam940 = new DetectorType("Sam940"); + public final static DetectorType Sam945 = new DetectorType("Sam945"); + public final static DetectorType Srpm210 = new DetectorType("Srpm210"); + public final static DetectorType RIIDEyeNaI = new DetectorType("RIIDEyeNaI"); + public final static DetectorType RIIDEyeLaBr = new DetectorType("RIIDEyeLaBr"); + public final static DetectorType RadSeekerNaI = new DetectorType("RadSeekerNaI"); + public final static DetectorType RadSeekerLaBr = new DetectorType("RadSeekerLaBr"); + public final static DetectorType VerifinderNaI = new DetectorType("VerifinderNaI"); + public final static DetectorType VerifinderLaBr = new DetectorType("VerifinderLaBr"); + public final static DetectorType KromekD3S = new DetectorType("KromekD3S"); + public final static DetectorType Fulcrum = new DetectorType("Fulcrum"); + public final static DetectorType Fulcrum40h = new DetectorType("Fulcrum40h"); + public final static DetectorType Sam950 = new DetectorType("Sam950"); + public final static DetectorType Unknown = new DetectorType("Unknown"); + + public final int swigValue() { + return swigValue; + } + + public String toString() { + return swigName; + } + + public static DetectorType swigToEnum(int swigValue) { + if (swigValue < swigValues.length && swigValue >= 0 && swigValues[swigValue].swigValue == swigValue) + return swigValues[swigValue]; + for (int i = 0; i < swigValues.length; i++) + if (swigValues[i].swigValue == swigValue) + return swigValues[i]; + throw new IllegalArgumentException("No enum " + DetectorType.class + " with value " + swigValue); + } + + private DetectorType(String swigName) { + this.swigName = swigName; + this.swigValue = swigNext++; + } + + private DetectorType(String swigName, int swigValue) { + this.swigName = swigName; + this.swigValue = swigValue; + swigNext = swigValue+1; + } + + private DetectorType(String swigName, DetectorType swigEnum) { + this.swigName = swigName; + this.swigValue = swigEnum.swigValue; + swigNext = this.swigValue+1; + } + + private static DetectorType[] swigValues = { Exploranium, IdentiFinder, IdentiFinderNG, IdentiFinderLaBr3, IdentiFinderTungsten, IdentiFinderR425NaI, IdentiFinderR425LaBr, IdentiFinderR500NaI, IdentiFinderR500LaBr, IdentiFinderUnknown, DetectiveUnknown, DetectiveEx, DetectiveEx100, DetectiveEx200, DetectiveX, SAIC8, Falcon5000, MicroDetective, MicroRaider, RadiaCode, Interceptor, RadHunterNaI, RadHunterLaBr3, Rsi701, Rsi705, AvidRsi, OrtecRadEagleNai, OrtecRadEagleCeBr2Inch, OrtecRadEagleCeBr3Inch, OrtecRadEagleLaBr, Sam940LaBr3, Sam940, Sam945, Srpm210, RIIDEyeNaI, RIIDEyeLaBr, RadSeekerNaI, RadSeekerLaBr, VerifinderNaI, VerifinderLaBr, KromekD3S, Fulcrum, Fulcrum40h, Sam950, Unknown }; + private static int swigNext = 0; + private final int swigValue; + private final String swigName; +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/EnergyCalType.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/EnergyCalType.java new file mode 100644 index 00000000..be25e80a --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/EnergyCalType.java @@ -0,0 +1,56 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public final class EnergyCalType { + public final static EnergyCalType Polynomial = new EnergyCalType("Polynomial"); + public final static EnergyCalType FullRangeFraction = new EnergyCalType("FullRangeFraction"); + public final static EnergyCalType LowerChannelEdge = new EnergyCalType("LowerChannelEdge"); + public final static EnergyCalType UnspecifiedUsingDefaultPolynomial = new EnergyCalType("UnspecifiedUsingDefaultPolynomial"); + public final static EnergyCalType InvalidEquationType = new EnergyCalType("InvalidEquationType"); + + public final int swigValue() { + return swigValue; + } + + public String toString() { + return swigName; + } + + public static EnergyCalType swigToEnum(int swigValue) { + if (swigValue < swigValues.length && swigValue >= 0 && swigValues[swigValue].swigValue == swigValue) + return swigValues[swigValue]; + for (int i = 0; i < swigValues.length; i++) + if (swigValues[i].swigValue == swigValue) + return swigValues[i]; + throw new IllegalArgumentException("No enum " + EnergyCalType.class + " with value " + swigValue); + } + + private EnergyCalType(String swigName) { + this.swigName = swigName; + this.swigValue = swigNext++; + } + + private EnergyCalType(String swigName, int swigValue) { + this.swigName = swigName; + this.swigValue = swigValue; + swigNext = swigValue+1; + } + + private EnergyCalType(String swigName, EnergyCalType swigEnum) { + this.swigName = swigName; + this.swigValue = swigEnum.swigValue; + swigNext = this.swigValue+1; + } + + private static EnergyCalType[] swigValues = { Polynomial, FullRangeFraction, LowerChannelEdge, UnspecifiedUsingDefaultPolynomial, InvalidEquationType }; + private static int swigNext = 0; + private final int swigValue; + private final String swigName; +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/EnergyCalibration.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/EnergyCalibration.java new file mode 100644 index 00000000..97b3a32d --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/EnergyCalibration.java @@ -0,0 +1,128 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class EnergyCalibration { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected EnergyCalibration(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(EnergyCalibration obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(EnergyCalibration obj) { + long ptr = 0; + if (obj != null) { + if (!obj.swigCMemOwn) + throw new RuntimeException("Cannot release ownership as memory is not owned"); + ptr = obj.swigCPtr; + obj.swigCMemOwn = false; + obj.delete(); + } + return ptr; + } + + @SuppressWarnings({"deprecation", "removal"}) + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + SpecUtilsSwigJNI.delete_EnergyCalibration(swigCPtr); + } + swigCPtr = 0; + } + } + + public EnergyCalType type() { + return EnergyCalType.swigToEnum(SpecUtilsSwigJNI.EnergyCalibration_type(swigCPtr, this)); + } + + public boolean valid() { + return SpecUtilsSwigJNI.EnergyCalibration_valid(swigCPtr, this); + } + + public FloatVector coefficients() { + return new FloatVector(SpecUtilsSwigJNI.EnergyCalibration_coefficients(swigCPtr, this), true); + } + + public SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t deviation_pairs() { + return new SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t(SpecUtilsSwigJNI.EnergyCalibration_deviation_pairs(swigCPtr, this), false); + } + + public FloatVector channel_energies() { + long cPtr = SpecUtilsSwigJNI.EnergyCalibration_channel_energies(swigCPtr, this); + return (cPtr == 0) ? null : new FloatVector(cPtr, true); + } + + public long num_channels() { + return SpecUtilsSwigJNI.EnergyCalibration_num_channels(swigCPtr, this); + } + + public EnergyCalibration() { + this(SpecUtilsSwigJNI.new_EnergyCalibration(), true); + } + + public void set_polynomial(long num_channels, FloatVector coeffs, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t dev_pairs) { + SpecUtilsSwigJNI.EnergyCalibration_set_polynomial(swigCPtr, this, num_channels, FloatVector.getCPtr(coeffs), coeffs, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t.getCPtr(dev_pairs)); + } + + public void set_default_polynomial(long num_channels, FloatVector coeffs, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t dev_pairs) { + SpecUtilsSwigJNI.EnergyCalibration_set_default_polynomial(swigCPtr, this, num_channels, FloatVector.getCPtr(coeffs), coeffs, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t.getCPtr(dev_pairs)); + } + + public void set_full_range_fraction(long num_channels, FloatVector coeffs, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t dev_pairs) { + SpecUtilsSwigJNI.EnergyCalibration_set_full_range_fraction(swigCPtr, this, num_channels, FloatVector.getCPtr(coeffs), coeffs, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t.getCPtr(dev_pairs)); + } + + public void set_lower_channel_energy(long num_channels, FloatVector channel_energies) { + SpecUtilsSwigJNI.EnergyCalibration_set_lower_channel_energy__SWIG_0(swigCPtr, this, num_channels, FloatVector.getCPtr(channel_energies), channel_energies); + } + + public long memmorysize() { + return SpecUtilsSwigJNI.EnergyCalibration_memmorysize(swigCPtr, this); + } + + public double channel_for_energy(double energy) { + return SpecUtilsSwigJNI.EnergyCalibration_channel_for_energy(swigCPtr, this, energy); + } + + public double energy_for_channel(double channel) { + return SpecUtilsSwigJNI.EnergyCalibration_energy_for_channel(swigCPtr, this, channel); + } + + public float lower_energy() { + return SpecUtilsSwigJNI.EnergyCalibration_lower_energy(swigCPtr, this); + } + + public float upper_energy() { + return SpecUtilsSwigJNI.EnergyCalibration_upper_energy(swigCPtr, this); + } + + public static long getSm_min_channels() { + return SpecUtilsSwigJNI.EnergyCalibration_sm_min_channels_get(); + } + + public static long getSm_max_channels() { + return SpecUtilsSwigJNI.EnergyCalibration_sm_max_channels_get(); + } + + public static float getSm_polynomial_offset_limit() { + return SpecUtilsSwigJNI.EnergyCalibration_sm_polynomial_offset_limit_get(); + } + +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/FloatVector.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/FloatVector.java new file mode 100644 index 00000000..8a6b3d84 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/FloatVector.java @@ -0,0 +1,158 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class FloatVector extends java.util.AbstractList implements java.util.RandomAccess { + private transient long swigCPtr; + private transient boolean swigCMemOwn; + + protected FloatVector(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(FloatVector obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected void swigSetCMemOwn(boolean own) { + swigCMemOwn = own; + } + + @SuppressWarnings({"deprecation", "removal"}) + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + SpecUtilsSwigJNI.delete_FloatVector(swigCPtr); + } + swigCPtr = 0; + } + } + + @SuppressWarnings("this-escape") + public FloatVector(float[] initialElements) { + this(); + doReserve(initialElements.length); + + for (float element : initialElements) { + doAdd(element); + } + } + + @SuppressWarnings("this-escape") + public FloatVector(Iterable initialElements) { + this(); + for (float element : initialElements) { + doAdd(element); + } + } + + public Float get(int index) { + return doGet(index); + } + + public Float set(int index, Float e) { + return doSet(index, e); + } + + public boolean add(Float e) { + modCount++; + doAdd(e); + return true; + } + + public void add(int index, Float e) { + modCount++; + doAdd(index, e); + } + + public Float remove(int index) { + modCount++; + return doRemove(index); + } + + protected void removeRange(int fromIndex, int toIndex) { + modCount++; + doRemoveRange(fromIndex, toIndex); + } + + public int size() { + return doSize(); + } + + public int capacity() { + return doCapacity(); + } + + public void reserve(int n) { + doReserve(n); + } + + public FloatVector() { + this(SpecUtilsSwigJNI.new_FloatVector__SWIG_0(), true); + } + + public FloatVector(FloatVector other) { + this(SpecUtilsSwigJNI.new_FloatVector__SWIG_1(FloatVector.getCPtr(other), other), true); + } + + public boolean isEmpty() { + return SpecUtilsSwigJNI.FloatVector_isEmpty(swigCPtr, this); + } + + public void clear() { + SpecUtilsSwigJNI.FloatVector_clear(swigCPtr, this); + } + + public FloatVector(int count, float value) { + this(SpecUtilsSwigJNI.new_FloatVector__SWIG_2(count, value), true); + } + + private int doCapacity() { + return SpecUtilsSwigJNI.FloatVector_doCapacity(swigCPtr, this); + } + + private void doReserve(int n) { + SpecUtilsSwigJNI.FloatVector_doReserve(swigCPtr, this, n); + } + + private int doSize() { + return SpecUtilsSwigJNI.FloatVector_doSize(swigCPtr, this); + } + + private void doAdd(float x) { + SpecUtilsSwigJNI.FloatVector_doAdd__SWIG_0(swigCPtr, this, x); + } + + private void doAdd(int index, float x) { + SpecUtilsSwigJNI.FloatVector_doAdd__SWIG_1(swigCPtr, this, index, x); + } + + private float doRemove(int index) { + return SpecUtilsSwigJNI.FloatVector_doRemove(swigCPtr, this, index); + } + + private float doGet(int index) { + return SpecUtilsSwigJNI.FloatVector_doGet(swigCPtr, this, index); + } + + private float doSet(int index, float val) { + return SpecUtilsSwigJNI.FloatVector_doSet(swigCPtr, this, index, val); + } + + private void doRemoveRange(int fromIndex, int toIndex) { + SpecUtilsSwigJNI.FloatVector_doRemoveRange(swigCPtr, this, fromIndex, toIndex); + } + +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/IntVector.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/IntVector.java new file mode 100644 index 00000000..ab57ed1a --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/IntVector.java @@ -0,0 +1,166 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class IntVector extends java.util.AbstractList implements java.util.RandomAccess { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected IntVector(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(IntVector obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(IntVector obj) { + long ptr = 0; + if (obj != null) { + if (!obj.swigCMemOwn) + throw new RuntimeException("Cannot release ownership as memory is not owned"); + ptr = obj.swigCPtr; + obj.swigCMemOwn = false; + obj.delete(); + } + return ptr; + } + + @SuppressWarnings({"deprecation", "removal"}) + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + SpecUtilsSwigJNI.delete_IntVector(swigCPtr); + } + swigCPtr = 0; + } + } + + @SuppressWarnings("this-escape") + public IntVector(int[] initialElements) { + this(); + doReserve(initialElements.length); + + for (int element : initialElements) { + doAdd(element); + } + } + + @SuppressWarnings("this-escape") + public IntVector(Iterable initialElements) { + this(); + for (int element : initialElements) { + doAdd(element); + } + } + + public Integer get(int index) { + return doGet(index); + } + + public Integer set(int index, Integer e) { + return doSet(index, e); + } + + public boolean add(Integer e) { + modCount++; + doAdd(e); + return true; + } + + public void add(int index, Integer e) { + modCount++; + doAdd(index, e); + } + + public Integer remove(int index) { + modCount++; + return doRemove(index); + } + + protected void removeRange(int fromIndex, int toIndex) { + modCount++; + doRemoveRange(fromIndex, toIndex); + } + + public int size() { + return doSize(); + } + + public int capacity() { + return doCapacity(); + } + + public void reserve(int n) { + doReserve(n); + } + + public IntVector() { + this(SpecUtilsSwigJNI.new_IntVector__SWIG_0(), true); + } + + public IntVector(IntVector other) { + this(SpecUtilsSwigJNI.new_IntVector__SWIG_1(IntVector.getCPtr(other), other), true); + } + + public boolean isEmpty() { + return SpecUtilsSwigJNI.IntVector_isEmpty(swigCPtr, this); + } + + public void clear() { + SpecUtilsSwigJNI.IntVector_clear(swigCPtr, this); + } + + public IntVector(int count, int value) { + this(SpecUtilsSwigJNI.new_IntVector__SWIG_2(count, value), true); + } + + private int doCapacity() { + return SpecUtilsSwigJNI.IntVector_doCapacity(swigCPtr, this); + } + + private void doReserve(int n) { + SpecUtilsSwigJNI.IntVector_doReserve(swigCPtr, this, n); + } + + private int doSize() { + return SpecUtilsSwigJNI.IntVector_doSize(swigCPtr, this); + } + + private void doAdd(int x) { + SpecUtilsSwigJNI.IntVector_doAdd__SWIG_0(swigCPtr, this, x); + } + + private void doAdd(int index, int x) { + SpecUtilsSwigJNI.IntVector_doAdd__SWIG_1(swigCPtr, this, index, x); + } + + private int doRemove(int index) { + return SpecUtilsSwigJNI.IntVector_doRemove(swigCPtr, this, index); + } + + private int doGet(int index) { + return SpecUtilsSwigJNI.IntVector_doGet(swigCPtr, this, index); + } + + private int doSet(int index, int val) { + return SpecUtilsSwigJNI.IntVector_doSet(swigCPtr, this, index, val); + } + + private void doRemoveRange(int fromIndex, int toIndex) { + SpecUtilsSwigJNI.IntVector_doRemoveRange(swigCPtr, this, fromIndex, toIndex); + } + +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/Measurement.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/Measurement.java new file mode 100644 index 00000000..3f06e399 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/Measurement.java @@ -0,0 +1,387 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class Measurement { + private transient long swigCPtr; + private transient boolean swigCMemOwn; + + protected Measurement(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(Measurement obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected void swigSetCMemOwn(boolean own) { + swigCMemOwn = own; + } + + @SuppressWarnings({"deprecation", "removal"}) + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + SpecUtilsSwigJNI.delete_Measurement(swigCPtr); + } + swigCPtr = 0; + } + } + + public Measurement() { + this(SpecUtilsSwigJNI.new_Measurement(), true); + } + + public Measurement operatorEqual(Measurement rhs) { + return new Measurement(SpecUtilsSwigJNI.Measurement_operatorEqual(swigCPtr, this, Measurement.getCPtr(rhs), rhs), true); + } + + public long memmorysize() { + return SpecUtilsSwigJNI.Measurement_memmorysize(swigCPtr, this); + } + + public float live_time() { + return SpecUtilsSwigJNI.Measurement_live_time(swigCPtr, this); + } + + public float real_time() { + return SpecUtilsSwigJNI.Measurement_real_time(swigCPtr, this); + } + + public boolean contained_neutron() { + return SpecUtilsSwigJNI.Measurement_contained_neutron(swigCPtr, this); + } + + public int sample_number() { + return SpecUtilsSwigJNI.Measurement_sample_number(swigCPtr, this); + } + + public String title() { + return SpecUtilsSwigJNI.Measurement_title(swigCPtr, this); + } + + public OccupancyStatus occupied() { + return OccupancyStatus.swigToEnum(SpecUtilsSwigJNI.Measurement_occupied(swigCPtr, this)); + } + + public double gamma_count_sum() { + return SpecUtilsSwigJNI.Measurement_gamma_count_sum(swigCPtr, this); + } + + public float neutron_live_time() { + return SpecUtilsSwigJNI.Measurement_neutron_live_time(swigCPtr, this); + } + + public double neutron_counts_sum() { + return SpecUtilsSwigJNI.Measurement_neutron_counts_sum(swigCPtr, this); + } + + public float speed() { + return SpecUtilsSwigJNI.Measurement_speed(swigCPtr, this); + } + + public float dx() { + return SpecUtilsSwigJNI.Measurement_dx(swigCPtr, this); + } + + public float dy() { + return SpecUtilsSwigJNI.Measurement_dy(swigCPtr, this); + } + + public double latitude() { + return SpecUtilsSwigJNI.Measurement_latitude(swigCPtr, this); + } + + public double longitude() { + return SpecUtilsSwigJNI.Measurement_longitude(swigCPtr, this); + } + + public boolean has_gps_info() { + return SpecUtilsSwigJNI.Measurement_has_gps_info(swigCPtr, this); + } + + public float dose_rate() { + return SpecUtilsSwigJNI.Measurement_dose_rate(swigCPtr, this); + } + + public float exposure_rate() { + return SpecUtilsSwigJNI.Measurement_exposure_rate(swigCPtr, this); + } + + public SWIGTYPE_p_std__chrono__time_pointT_std__chrono__system_clock_std__chrono__microseconds_t position_time() { + return new SWIGTYPE_p_std__chrono__time_pointT_std__chrono__system_clock_std__chrono__microseconds_t(SpecUtilsSwigJNI.Measurement_position_time(swigCPtr, this), true); + } + + public String detector_name() { + return SpecUtilsSwigJNI.Measurement_detector_name(swigCPtr, this); + } + + public int detector_number() { + return SpecUtilsSwigJNI.Measurement_detector_number(swigCPtr, this); + } + + public String detector_type() { + return SpecUtilsSwigJNI.Measurement_detector_type(swigCPtr, this); + } + + public QualityStatus quality_status() { + return QualityStatus.swigToEnum(SpecUtilsSwigJNI.Measurement_quality_status(swigCPtr, this)); + } + + public SourceType source_type() { + return SourceType.swigToEnum(SpecUtilsSwigJNI.Measurement_source_type(swigCPtr, this)); + } + + public StringVector remarks() { + return new StringVector(SpecUtilsSwigJNI.Measurement_remarks(swigCPtr, this), false); + } + + public StringVector parse_warnings() { + return new StringVector(SpecUtilsSwigJNI.Measurement_parse_warnings(swigCPtr, this), false); + } + + public SWIGTYPE_p_std__chrono__time_pointT_std__chrono__system_clock_std__chrono__microseconds_t start_time() { + return new SWIGTYPE_p_std__chrono__time_pointT_std__chrono__system_clock_std__chrono__microseconds_t(SpecUtilsSwigJNI.Measurement_start_time(swigCPtr, this), false); + } + + public SWIGTYPE_p_std__chrono__time_pointT_std__chrono__system_clock_std__chrono__microseconds_t start_time_copy() { + return new SWIGTYPE_p_std__chrono__time_pointT_std__chrono__system_clock_std__chrono__microseconds_t(SpecUtilsSwigJNI.Measurement_start_time_copy(swigCPtr, this), true); + } + + public EnergyCalType energy_calibration_model() { + return EnergyCalType.swigToEnum(SpecUtilsSwigJNI.Measurement_energy_calibration_model(swigCPtr, this)); + } + + public FloatVector calibration_coeffs() { + return new FloatVector(SpecUtilsSwigJNI.Measurement_calibration_coeffs(swigCPtr, this), true); + } + + public SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t deviation_pairs() { + return new SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t(SpecUtilsSwigJNI.Measurement_deviation_pairs(swigCPtr, this), false); + } + + public SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_const_t energy_calibration() { + return new SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_const_t(SpecUtilsSwigJNI.Measurement_energy_calibration(swigCPtr, this), true); + } + + public FloatVector channel_energies() { + long cPtr = SpecUtilsSwigJNI.Measurement_channel_energies(swigCPtr, this); + return (cPtr == 0) ? null : new FloatVector(cPtr, true); + } + + public FloatVector gamma_counts() { + long cPtr = SpecUtilsSwigJNI.Measurement_gamma_counts(swigCPtr, this); + return (cPtr == 0) ? null : new FloatVector(cPtr, true); + } + + public FloatVector neutron_counts() { + return new FloatVector(SpecUtilsSwigJNI.Measurement_neutron_counts(swigCPtr, this), true); + } + + public SWIGTYPE_p_std__shared_ptrT_SpecUtils__LocationState_const_t location_state() { + return new SWIGTYPE_p_std__shared_ptrT_SpecUtils__LocationState_const_t(SpecUtilsSwigJNI.Measurement_location_state(swigCPtr, this), false); + } + + public void set_title(String title) { + SpecUtilsSwigJNI.Measurement_set_title(swigCPtr, this, title); + } + + public void set_start_time(SWIGTYPE_p_std__chrono__time_pointT_std__chrono__system_clock_std__chrono__microseconds_t timestamp) { + SpecUtilsSwigJNI.Measurement_set_start_time(swigCPtr, this, SWIGTYPE_p_std__chrono__time_pointT_std__chrono__system_clock_std__chrono__microseconds_t.getCPtr(timestamp)); + } + + public void set_remarks(StringVector remarks) { + SpecUtilsSwigJNI.Measurement_set_remarks(swigCPtr, this, StringVector.getCPtr(remarks), remarks); + } + + public void set_parse_warnings(StringVector warnings) { + SpecUtilsSwigJNI.Measurement_set_parse_warnings(swigCPtr, this, StringVector.getCPtr(warnings), warnings); + } + + public void set_source_type(SourceType type) { + SpecUtilsSwigJNI.Measurement_set_source_type(swigCPtr, this, type.swigValue()); + } + + public void set_position(double longitude, double latitude, SWIGTYPE_p_std__chrono__time_pointT_std__chrono__system_clock_std__chrono__microseconds_t pos_time) { + SpecUtilsSwigJNI.Measurement_set_position(swigCPtr, this, longitude, latitude, SWIGTYPE_p_std__chrono__time_pointT_std__chrono__system_clock_std__chrono__microseconds_t.getCPtr(pos_time)); + } + + public void set_sample_number(int samplenum) { + SpecUtilsSwigJNI.Measurement_set_sample_number(swigCPtr, this, samplenum); + } + + public void set_occupancy_status(OccupancyStatus status) { + SpecUtilsSwigJNI.Measurement_set_occupancy_status(swigCPtr, this, status.swigValue()); + } + + public void set_detector_name(String name) { + SpecUtilsSwigJNI.Measurement_set_detector_name(swigCPtr, this, name); + } + + public void set_detector_number(int detnum) { + SpecUtilsSwigJNI.Measurement_set_detector_number(swigCPtr, this, detnum); + } + + public void set_gamma_counts(FloatVector counts, float livetime, float realtime) { + SpecUtilsSwigJNI.Measurement_set_gamma_counts(swigCPtr, this, FloatVector.getCPtr(counts), counts, livetime, realtime); + } + + public void set_neutron_counts(FloatVector counts, float neutron_live_time) { + SpecUtilsSwigJNI.Measurement_set_neutron_counts(swigCPtr, this, FloatVector.getCPtr(counts), counts, neutron_live_time); + } + + public long num_gamma_channels() { + return SpecUtilsSwigJNI.Measurement_num_gamma_channels(swigCPtr, this); + } + + public long find_gamma_channel(float energy) { + return SpecUtilsSwigJNI.Measurement_find_gamma_channel(swigCPtr, this, energy); + } + + public float gamma_channel_content(long channel) { + return SpecUtilsSwigJNI.Measurement_gamma_channel_content(swigCPtr, this, channel); + } + + public float gamma_channel_lower(long channel) { + return SpecUtilsSwigJNI.Measurement_gamma_channel_lower(swigCPtr, this, channel); + } + + public float gamma_channel_center(long channel) { + return SpecUtilsSwigJNI.Measurement_gamma_channel_center(swigCPtr, this, channel); + } + + public float gamma_channel_upper(long channel) { + return SpecUtilsSwigJNI.Measurement_gamma_channel_upper(swigCPtr, this, channel); + } + + public float gamma_channel_width(long channel) { + return SpecUtilsSwigJNI.Measurement_gamma_channel_width(swigCPtr, this, channel); + } + + public double gamma_integral(float lower_energy, float upper_energy) { + return SpecUtilsSwigJNI.Measurement_gamma_integral(swigCPtr, this, lower_energy, upper_energy); + } + + public double gamma_channels_sum(long startbin, long endbin) { + return SpecUtilsSwigJNI.Measurement_gamma_channels_sum(swigCPtr, this, startbin, endbin); + } + + public FloatVector gamma_channel_energies() { + long cPtr = SpecUtilsSwigJNI.Measurement_gamma_channel_energies(swigCPtr, this); + return (cPtr == 0) ? null : new FloatVector(cPtr, true); + } + + public FloatVector gamma_channel_contents() { + long cPtr = SpecUtilsSwigJNI.Measurement_gamma_channel_contents(swigCPtr, this); + return (cPtr == 0) ? null : new FloatVector(cPtr, true); + } + + public float gamma_energy_min() { + return SpecUtilsSwigJNI.Measurement_gamma_energy_min(swigCPtr, this); + } + + public float gamma_energy_max() { + return SpecUtilsSwigJNI.Measurement_gamma_energy_max(swigCPtr, this); + } + + public SWIGTYPE_p_uint32_t derived_data_properties() { + return new SWIGTYPE_p_uint32_t(SpecUtilsSwigJNI.Measurement_derived_data_properties(swigCPtr, this), true); + } + + public boolean write_2006_N42_xml(SWIGTYPE_p_std__ostream ostr) { + return SpecUtilsSwigJNI.Measurement_write_2006_N42_xml(swigCPtr, this, SWIGTYPE_p_std__ostream.getCPtr(ostr)); + } + + public boolean write_csv(SWIGTYPE_p_std__ostream ostr) { + return SpecUtilsSwigJNI.Measurement_write_csv(swigCPtr, this, SWIGTYPE_p_std__ostream.getCPtr(ostr)); + } + + public boolean write_txt(SWIGTYPE_p_std__ostream ostr) { + return SpecUtilsSwigJNI.Measurement_write_txt(swigCPtr, this, SWIGTYPE_p_std__ostream.getCPtr(ostr)); + } + + public void reset() { + SpecUtilsSwigJNI.Measurement_reset(swigCPtr, this); + } + + public void combine_gamma_channels(long nchannel) { + SpecUtilsSwigJNI.Measurement_combine_gamma_channels(swigCPtr, this, nchannel); + } + + public void truncate_gamma_channels(long keep_first_channel, long keep_last_channel, boolean keep_under_over_flow) { + SpecUtilsSwigJNI.Measurement_truncate_gamma_channels(swigCPtr, this, keep_first_channel, keep_last_channel, keep_under_over_flow); + } + + public void rebin(SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_const_t cal) { + SpecUtilsSwigJNI.Measurement_rebin(swigCPtr, this, SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_const_t.getCPtr(cal)); + } + + public void set_energy_calibration(SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_const_t cal) { + SpecUtilsSwigJNI.Measurement_set_energy_calibration(swigCPtr, this, SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_const_t.getCPtr(cal)); + } + + public void set_info_from_2006_N42_spectrum_node(SWIGTYPE_p_rapidxml__xml_nodeT_char_t spectrum) { + SpecUtilsSwigJNI.Measurement_set_info_from_2006_N42_spectrum_node(swigCPtr, this, SWIGTYPE_p_rapidxml__xml_nodeT_char_t.getCPtr(spectrum)); + } + + public final static class DerivedDataProperties { + public final static Measurement.DerivedDataProperties IsDerived = new Measurement.DerivedDataProperties("IsDerived", SpecUtilsSwigJNI.Measurement_DerivedDataProperties_IsDerived_get()); + public final static Measurement.DerivedDataProperties ItemOfInterestSum = new Measurement.DerivedDataProperties("ItemOfInterestSum", SpecUtilsSwigJNI.Measurement_DerivedDataProperties_ItemOfInterestSum_get()); + public final static Measurement.DerivedDataProperties UsedForAnalysis = new Measurement.DerivedDataProperties("UsedForAnalysis", SpecUtilsSwigJNI.Measurement_DerivedDataProperties_UsedForAnalysis_get()); + public final static Measurement.DerivedDataProperties ProcessedFurther = new Measurement.DerivedDataProperties("ProcessedFurther", SpecUtilsSwigJNI.Measurement_DerivedDataProperties_ProcessedFurther_get()); + public final static Measurement.DerivedDataProperties BackgroundSubtracted = new Measurement.DerivedDataProperties("BackgroundSubtracted", SpecUtilsSwigJNI.Measurement_DerivedDataProperties_BackgroundSubtracted_get()); + public final static Measurement.DerivedDataProperties IsBackground = new Measurement.DerivedDataProperties("IsBackground", SpecUtilsSwigJNI.Measurement_DerivedDataProperties_IsBackground_get()); + + public final int swigValue() { + return swigValue; + } + + public String toString() { + return swigName; + } + + public static DerivedDataProperties swigToEnum(int swigValue) { + if (swigValue < swigValues.length && swigValue >= 0 && swigValues[swigValue].swigValue == swigValue) + return swigValues[swigValue]; + for (int i = 0; i < swigValues.length; i++) + if (swigValues[i].swigValue == swigValue) + return swigValues[i]; + throw new IllegalArgumentException("No enum " + DerivedDataProperties.class + " with value " + swigValue); + } + + private DerivedDataProperties(String swigName) { + this.swigName = swigName; + this.swigValue = swigNext++; + } + + private DerivedDataProperties(String swigName, int swigValue) { + this.swigName = swigName; + this.swigValue = swigValue; + swigNext = swigValue+1; + } + + private DerivedDataProperties(String swigName, DerivedDataProperties swigEnum) { + this.swigName = swigName; + this.swigValue = swigEnum.swigValue; + swigNext = this.swigValue+1; + } + + private static DerivedDataProperties[] swigValues = { IsDerived, ItemOfInterestSum, UsedForAnalysis, ProcessedFurther, BackgroundSubtracted, IsBackground }; + private static int swigNext = 0; + private final int swigValue; + private final String swigName; + } + +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/MultimediaData.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/MultimediaData.java new file mode 100644 index 00000000..61d8f1cf --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/MultimediaData.java @@ -0,0 +1,157 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class MultimediaData { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected MultimediaData(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(MultimediaData obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(MultimediaData obj) { + long ptr = 0; + if (obj != null) { + if (!obj.swigCMemOwn) + throw new RuntimeException("Cannot release ownership as memory is not owned"); + ptr = obj.swigCPtr; + obj.swigCMemOwn = false; + obj.delete(); + } + return ptr; + } + + @SuppressWarnings({"deprecation", "removal"}) + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + SpecUtilsSwigJNI.delete_MultimediaData(swigCPtr); + } + swigCPtr = 0; + } + } + + public void setRemark_(String value) { + SpecUtilsSwigJNI.MultimediaData_remark__set(swigCPtr, this, value); + } + + public String getRemark_() { + return SpecUtilsSwigJNI.MultimediaData_remark__get(swigCPtr, this); + } + + public void setDescriptions_(String value) { + SpecUtilsSwigJNI.MultimediaData_descriptions__set(swigCPtr, this, value); + } + + public String getDescriptions_() { + return SpecUtilsSwigJNI.MultimediaData_descriptions__get(swigCPtr, this); + } + + public void setData_(SWIGTYPE_p_std__vectorT_char_t value) { + SpecUtilsSwigJNI.MultimediaData_data__set(swigCPtr, this, SWIGTYPE_p_std__vectorT_char_t.getCPtr(value)); + } + + public SWIGTYPE_p_std__vectorT_char_t getData_() { + long cPtr = SpecUtilsSwigJNI.MultimediaData_data__get(swigCPtr, this); + return (cPtr == 0) ? null : new SWIGTYPE_p_std__vectorT_char_t(cPtr, false); + } + + public void setData_encoding_(MultimediaData.EncodingType value) { + SpecUtilsSwigJNI.MultimediaData_data_encoding__set(swigCPtr, this, value.swigValue()); + } + + public MultimediaData.EncodingType getData_encoding_() { + return MultimediaData.EncodingType.swigToEnum(SpecUtilsSwigJNI.MultimediaData_data_encoding__get(swigCPtr, this)); + } + + public void setCapture_start_time_(SWIGTYPE_p_std__chrono__time_pointT_std__chrono__system_clock_std__chrono__microseconds_t value) { + SpecUtilsSwigJNI.MultimediaData_capture_start_time__set(swigCPtr, this, SWIGTYPE_p_std__chrono__time_pointT_std__chrono__system_clock_std__chrono__microseconds_t.getCPtr(value)); + } + + public SWIGTYPE_p_std__chrono__time_pointT_std__chrono__system_clock_std__chrono__microseconds_t getCapture_start_time_() { + return new SWIGTYPE_p_std__chrono__time_pointT_std__chrono__system_clock_std__chrono__microseconds_t(SpecUtilsSwigJNI.MultimediaData_capture_start_time__get(swigCPtr, this), true); + } + + public void setFile_uri_(String value) { + SpecUtilsSwigJNI.MultimediaData_file_uri__set(swigCPtr, this, value); + } + + public String getFile_uri_() { + return SpecUtilsSwigJNI.MultimediaData_file_uri__get(swigCPtr, this); + } + + public void setMime_type_(String value) { + SpecUtilsSwigJNI.MultimediaData_mime_type__set(swigCPtr, this, value); + } + + public String getMime_type_() { + return SpecUtilsSwigJNI.MultimediaData_mime_type__get(swigCPtr, this); + } + + public MultimediaData() { + this(SpecUtilsSwigJNI.new_MultimediaData(), true); + } + + public final static class EncodingType { + public final static MultimediaData.EncodingType BinaryUTF8 = new MultimediaData.EncodingType("BinaryUTF8"); + public final static MultimediaData.EncodingType BinaryHex = new MultimediaData.EncodingType("BinaryHex"); + public final static MultimediaData.EncodingType BinaryBase64 = new MultimediaData.EncodingType("BinaryBase64"); + + public final int swigValue() { + return swigValue; + } + + public String toString() { + return swigName; + } + + public static EncodingType swigToEnum(int swigValue) { + if (swigValue < swigValues.length && swigValue >= 0 && swigValues[swigValue].swigValue == swigValue) + return swigValues[swigValue]; + for (int i = 0; i < swigValues.length; i++) + if (swigValues[i].swigValue == swigValue) + return swigValues[i]; + throw new IllegalArgumentException("No enum " + EncodingType.class + " with value " + swigValue); + } + + private EncodingType(String swigName) { + this.swigName = swigName; + this.swigValue = swigNext++; + } + + private EncodingType(String swigName, int swigValue) { + this.swigName = swigName; + this.swigValue = swigValue; + swigNext = swigValue+1; + } + + private EncodingType(String swigName, EncodingType swigEnum) { + this.swigName = swigName; + this.swigValue = swigEnum.swigValue; + swigNext = this.swigValue+1; + } + + private static EncodingType[] swigValues = { BinaryUTF8, BinaryHex, BinaryBase64 }; + private static int swigNext = 0; + private final int swigValue; + private final String swigName; + } + +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/OccupancyStatus.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/OccupancyStatus.java new file mode 100644 index 00000000..4f87097a --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/OccupancyStatus.java @@ -0,0 +1,54 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public final class OccupancyStatus { + public final static OccupancyStatus NotOccupied = new OccupancyStatus("NotOccupied"); + public final static OccupancyStatus Occupied = new OccupancyStatus("Occupied"); + public final static OccupancyStatus Unknown = new OccupancyStatus("Unknown"); + + public final int swigValue() { + return swigValue; + } + + public String toString() { + return swigName; + } + + public static OccupancyStatus swigToEnum(int swigValue) { + if (swigValue < swigValues.length && swigValue >= 0 && swigValues[swigValue].swigValue == swigValue) + return swigValues[swigValue]; + for (int i = 0; i < swigValues.length; i++) + if (swigValues[i].swigValue == swigValue) + return swigValues[i]; + throw new IllegalArgumentException("No enum " + OccupancyStatus.class + " with value " + swigValue); + } + + private OccupancyStatus(String swigName) { + this.swigName = swigName; + this.swigValue = swigNext++; + } + + private OccupancyStatus(String swigName, int swigValue) { + this.swigName = swigName; + this.swigValue = swigValue; + swigNext = swigValue+1; + } + + private OccupancyStatus(String swigName, OccupancyStatus swigEnum) { + this.swigName = swigName; + this.swigValue = swigEnum.swigValue; + swigNext = this.swigValue+1; + } + + private static OccupancyStatus[] swigValues = { NotOccupied, Occupied, Unknown }; + private static int swigNext = 0; + private final int swigValue; + private final String swigName; +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/ParserType.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/ParserType.java new file mode 100644 index 00000000..e951a056 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/ParserType.java @@ -0,0 +1,76 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public final class ParserType { + public final static ParserType N42_2006 = new ParserType("N42_2006"); + public final static ParserType N42_2012 = new ParserType("N42_2012"); + public final static ParserType Spc = new ParserType("Spc"); + public final static ParserType Exploranium = new ParserType("Exploranium"); + public final static ParserType Pcf = new ParserType("Pcf"); + public final static ParserType Chn = new ParserType("Chn"); + public final static ParserType SpeIaea = new ParserType("SpeIaea"); + public final static ParserType TxtOrCsv = new ParserType("TxtOrCsv"); + public final static ParserType Cnf = new ParserType("Cnf"); + public final static ParserType TracsMps = new ParserType("TracsMps"); + public final static ParserType Aram = new ParserType("Aram"); + public final static ParserType SPMDailyFile = new ParserType("SPMDailyFile"); + public final static ParserType AmptekMca = new ParserType("AmptekMca"); + public final static ParserType MicroRaider = new ParserType("MicroRaider"); + public final static ParserType RadiaCode = new ParserType("RadiaCode"); + public final static ParserType OrtecListMode = new ParserType("OrtecListMode"); + public final static ParserType LsrmSpe = new ParserType("LsrmSpe"); + public final static ParserType Tka = new ParserType("Tka"); + public final static ParserType MultiAct = new ParserType("MultiAct"); + public final static ParserType Phd = new ParserType("Phd"); + public final static ParserType Lzs = new ParserType("Lzs"); + public final static ParserType ScanDataXml = new ParserType("ScanDataXml"); + public final static ParserType Json = new ParserType("Json"); + public final static ParserType CaenHexagonGXml = new ParserType("CaenHexagonGXml"); + public final static ParserType Auto = new ParserType("Auto"); + + public final int swigValue() { + return swigValue; + } + + public String toString() { + return swigName; + } + + public static ParserType swigToEnum(int swigValue) { + if (swigValue < swigValues.length && swigValue >= 0 && swigValues[swigValue].swigValue == swigValue) + return swigValues[swigValue]; + for (int i = 0; i < swigValues.length; i++) + if (swigValues[i].swigValue == swigValue) + return swigValues[i]; + throw new IllegalArgumentException("No enum " + ParserType.class + " with value " + swigValue); + } + + private ParserType(String swigName) { + this.swigName = swigName; + this.swigValue = swigNext++; + } + + private ParserType(String swigName, int swigValue) { + this.swigName = swigName; + this.swigValue = swigValue; + swigNext = swigValue+1; + } + + private ParserType(String swigName, ParserType swigEnum) { + this.swigName = swigName; + this.swigValue = swigEnum.swigValue; + swigNext = this.swigValue+1; + } + + private static ParserType[] swigValues = { N42_2006, N42_2012, Spc, Exploranium, Pcf, Chn, SpeIaea, TxtOrCsv, Cnf, TracsMps, Aram, SPMDailyFile, AmptekMca, MicroRaider, RadiaCode, OrtecListMode, LsrmSpe, Tka, MultiAct, Phd, Lzs, ScanDataXml, Json, CaenHexagonGXml, Auto }; + private static int swigNext = 0; + private final int swigValue; + private final String swigName; +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/QualityStatus.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/QualityStatus.java new file mode 100644 index 00000000..4accb773 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/QualityStatus.java @@ -0,0 +1,55 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public final class QualityStatus { + public final static QualityStatus Good = new QualityStatus("Good"); + public final static QualityStatus Suspect = new QualityStatus("Suspect"); + public final static QualityStatus Bad = new QualityStatus("Bad"); + public final static QualityStatus Missing = new QualityStatus("Missing"); + + public final int swigValue() { + return swigValue; + } + + public String toString() { + return swigName; + } + + public static QualityStatus swigToEnum(int swigValue) { + if (swigValue < swigValues.length && swigValue >= 0 && swigValues[swigValue].swigValue == swigValue) + return swigValues[swigValue]; + for (int i = 0; i < swigValues.length; i++) + if (swigValues[i].swigValue == swigValue) + return swigValues[i]; + throw new IllegalArgumentException("No enum " + QualityStatus.class + " with value " + swigValue); + } + + private QualityStatus(String swigName) { + this.swigName = swigName; + this.swigValue = swigNext++; + } + + private QualityStatus(String swigName, int swigValue) { + this.swigName = swigName; + this.swigValue = swigValue; + swigNext = swigValue+1; + } + + private QualityStatus(String swigName, QualityStatus swigEnum) { + this.swigName = swigName; + this.swigValue = swigEnum.swigValue; + swigNext = this.swigValue+1; + } + + private static QualityStatus[] swigValues = { Good, Suspect, Bad, Missing }; + private static int swigNext = 0; + private final int swigValue; + private final String swigName; +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_rapidxml__xml_nodeT_char_t.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_rapidxml__xml_nodeT_char_t.java new file mode 100644 index 00000000..908f5bf5 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_rapidxml__xml_nodeT_char_t.java @@ -0,0 +1,29 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class SWIGTYPE_p_rapidxml__xml_nodeT_char_t { + private transient long swigCPtr; + + protected SWIGTYPE_p_rapidxml__xml_nodeT_char_t(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_rapidxml__xml_nodeT_char_t() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_rapidxml__xml_nodeT_char_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_rapidxml__xml_nodeT_char_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__chrono__time_pointT_std__chrono__system_clock_std__chrono__microseconds_t.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__chrono__time_pointT_std__chrono__system_clock_std__chrono__microseconds_t.java new file mode 100644 index 00000000..8625fc9c --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__chrono__time_pointT_std__chrono__system_clock_std__chrono__microseconds_t.java @@ -0,0 +1,29 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class SWIGTYPE_p_std__chrono__time_pointT_std__chrono__system_clock_std__chrono__microseconds_t { + private transient long swigCPtr; + + protected SWIGTYPE_p_std__chrono__time_pointT_std__chrono__system_clock_std__chrono__microseconds_t(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_std__chrono__time_pointT_std__chrono__system_clock_std__chrono__microseconds_t() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_std__chrono__time_pointT_std__chrono__system_clock_std__chrono__microseconds_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_std__chrono__time_pointT_std__chrono__system_clock_std__chrono__microseconds_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__istream.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__istream.java new file mode 100644 index 00000000..63091880 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__istream.java @@ -0,0 +1,29 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class SWIGTYPE_p_std__istream { + private transient long swigCPtr; + + protected SWIGTYPE_p_std__istream(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_std__istream() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_std__istream obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_std__istream obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__mapT_std__string_std__string_t.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__mapT_std__string_std__string_t.java new file mode 100644 index 00000000..a0748075 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__mapT_std__string_std__string_t.java @@ -0,0 +1,29 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class SWIGTYPE_p_std__mapT_std__string_std__string_t { + private transient long swigCPtr; + + protected SWIGTYPE_p_std__mapT_std__string_std__string_t(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_std__mapT_std__string_std__string_t() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_std__mapT_std__string_std__string_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_std__mapT_std__string_std__string_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__mutex.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__mutex.java new file mode 100644 index 00000000..d310158f --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__mutex.java @@ -0,0 +1,29 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class SWIGTYPE_p_std__mutex { + private transient long swigCPtr; + + protected SWIGTYPE_p_std__mutex(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_std__mutex() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_std__mutex obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_std__mutex obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__ostream.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__ostream.java new file mode 100644 index 00000000..46473636 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__ostream.java @@ -0,0 +1,29 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class SWIGTYPE_p_std__ostream { + private transient long swigCPtr; + + protected SWIGTYPE_p_std__ostream(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_std__ostream() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_std__ostream obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_std__ostream obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__recursive_mutex.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__recursive_mutex.java new file mode 100644 index 00000000..540ea0c3 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__recursive_mutex.java @@ -0,0 +1,29 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class SWIGTYPE_p_std__recursive_mutex { + private transient long swigCPtr; + + protected SWIGTYPE_p_std__recursive_mutex(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_std__recursive_mutex() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_std__recursive_mutex obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_std__recursive_mutex obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__setT_int_t.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__setT_int_t.java new file mode 100644 index 00000000..9991f8d5 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__setT_int_t.java @@ -0,0 +1,29 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class SWIGTYPE_p_std__setT_int_t { + private transient long swigCPtr; + + protected SWIGTYPE_p_std__setT_int_t(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_std__setT_int_t() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_std__setT_int_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_std__setT_int_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__setT_size_t_t.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__setT_size_t_t.java new file mode 100644 index 00000000..a306b4f6 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__setT_size_t_t.java @@ -0,0 +1,29 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class SWIGTYPE_p_std__setT_size_t_t { + private transient long swigCPtr; + + protected SWIGTYPE_p_std__setT_size_t_t(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_std__setT_size_t_t() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_std__setT_size_t_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_std__setT_size_t_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__setT_std__string_t.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__setT_std__string_t.java new file mode 100644 index 00000000..04c47b11 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__setT_std__string_t.java @@ -0,0 +1,29 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class SWIGTYPE_p_std__setT_std__string_t { + private transient long swigCPtr; + + protected SWIGTYPE_p_std__setT_std__string_t(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_std__setT_std__string_t() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_std__setT_std__string_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_std__setT_std__string_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__shared_ptrT_SpecUtils__DetectorAnalysis_const_t.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__shared_ptrT_SpecUtils__DetectorAnalysis_const_t.java new file mode 100644 index 00000000..cf779de9 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__shared_ptrT_SpecUtils__DetectorAnalysis_const_t.java @@ -0,0 +1,29 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class SWIGTYPE_p_std__shared_ptrT_SpecUtils__DetectorAnalysis_const_t { + private transient long swigCPtr; + + protected SWIGTYPE_p_std__shared_ptrT_SpecUtils__DetectorAnalysis_const_t(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_std__shared_ptrT_SpecUtils__DetectorAnalysis_const_t() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_std__shared_ptrT_SpecUtils__DetectorAnalysis_const_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_std__shared_ptrT_SpecUtils__DetectorAnalysis_const_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_const_t.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_const_t.java new file mode 100644 index 00000000..a213821d --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_const_t.java @@ -0,0 +1,29 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_const_t { + private transient long swigCPtr; + + protected SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_const_t(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_const_t() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_const_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_const_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_t.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_t.java new file mode 100644 index 00000000..61f00c07 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_t.java @@ -0,0 +1,29 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_t { + private transient long swigCPtr; + + protected SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_t(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_t() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__shared_ptrT_SpecUtils__LocationState_const_t.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__shared_ptrT_SpecUtils__LocationState_const_t.java new file mode 100644 index 00000000..14211f2e --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__shared_ptrT_SpecUtils__LocationState_const_t.java @@ -0,0 +1,29 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class SWIGTYPE_p_std__shared_ptrT_SpecUtils__LocationState_const_t { + private transient long swigCPtr; + + protected SWIGTYPE_p_std__shared_ptrT_SpecUtils__LocationState_const_t(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_std__shared_ptrT_SpecUtils__LocationState_const_t() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_std__shared_ptrT_SpecUtils__LocationState_const_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_std__shared_ptrT_SpecUtils__LocationState_const_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__shared_ptrT_rapidxml__xml_documentT_char_t_t.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__shared_ptrT_rapidxml__xml_documentT_char_t_t.java new file mode 100644 index 00000000..3fff4ef4 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__shared_ptrT_rapidxml__xml_documentT_char_t_t.java @@ -0,0 +1,29 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class SWIGTYPE_p_std__shared_ptrT_rapidxml__xml_documentT_char_t_t { + private transient long swigCPtr; + + protected SWIGTYPE_p_std__shared_ptrT_rapidxml__xml_documentT_char_t_t(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_std__shared_ptrT_rapidxml__xml_documentT_char_t_t() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_std__shared_ptrT_rapidxml__xml_documentT_char_t_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_std__shared_ptrT_rapidxml__xml_documentT_char_t_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__string.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__string.java new file mode 100644 index 00000000..d6fdd1be --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__string.java @@ -0,0 +1,29 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class SWIGTYPE_p_std__string { + private transient long swigCPtr; + + protected SWIGTYPE_p_std__string(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_std__string() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_std__string obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_std__string obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__vectorT_SpecUtils__DetectorAnalysisResult_t.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__vectorT_SpecUtils__DetectorAnalysisResult_t.java new file mode 100644 index 00000000..e13b8438 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__vectorT_SpecUtils__DetectorAnalysisResult_t.java @@ -0,0 +1,29 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class SWIGTYPE_p_std__vectorT_SpecUtils__DetectorAnalysisResult_t { + private transient long swigCPtr; + + protected SWIGTYPE_p_std__vectorT_SpecUtils__DetectorAnalysisResult_t(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_std__vectorT_SpecUtils__DetectorAnalysisResult_t() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_std__vectorT_SpecUtils__DetectorAnalysisResult_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_std__vectorT_SpecUtils__DetectorAnalysisResult_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__vectorT_char_t.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__vectorT_char_t.java new file mode 100644 index 00000000..6c25375e --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__vectorT_char_t.java @@ -0,0 +1,29 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class SWIGTYPE_p_std__vectorT_char_t { + private transient long swigCPtr; + + protected SWIGTYPE_p_std__vectorT_char_t(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_std__vectorT_char_t() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_std__vectorT_char_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_std__vectorT_char_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__vectorT_std__pairT_SpecUtils__Measurement_const_p_D3SpectrumExport__D3SpectrumOptions_t_t.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__vectorT_std__pairT_SpecUtils__Measurement_const_p_D3SpectrumExport__D3SpectrumOptions_t_t.java new file mode 100644 index 00000000..db28179b --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__vectorT_std__pairT_SpecUtils__Measurement_const_p_D3SpectrumExport__D3SpectrumOptions_t_t.java @@ -0,0 +1,29 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class SWIGTYPE_p_std__vectorT_std__pairT_SpecUtils__Measurement_const_p_D3SpectrumExport__D3SpectrumOptions_t_t { + private transient long swigCPtr; + + protected SWIGTYPE_p_std__vectorT_std__pairT_SpecUtils__Measurement_const_p_D3SpectrumExport__D3SpectrumOptions_t_t(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_std__vectorT_std__pairT_SpecUtils__Measurement_const_p_D3SpectrumExport__D3SpectrumOptions_t_t() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_std__vectorT_std__pairT_SpecUtils__Measurement_const_p_D3SpectrumExport__D3SpectrumOptions_t_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_std__vectorT_std__pairT_SpecUtils__Measurement_const_p_D3SpectrumExport__D3SpectrumOptions_t_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t.java new file mode 100644 index 00000000..e69e649e --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t.java @@ -0,0 +1,29 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t { + private transient long swigCPtr; + + protected SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_t.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_t.java new file mode 100644 index 00000000..ac3bcf2f --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_t.java @@ -0,0 +1,29 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_t { + private transient long swigCPtr; + + protected SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_t(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_t() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__vectorT_std__pairT_std__string_std__string_t_t.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__vectorT_std__pairT_std__string_std__string_t_t.java new file mode 100644 index 00000000..7b64919a --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__vectorT_std__pairT_std__string_std__string_t_t.java @@ -0,0 +1,29 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class SWIGTYPE_p_std__vectorT_std__pairT_std__string_std__string_t_t { + private transient long swigCPtr; + + protected SWIGTYPE_p_std__vectorT_std__pairT_std__string_std__string_t_t(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_std__vectorT_std__pairT_std__string_std__string_t_t() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_std__vectorT_std__pairT_std__string_std__string_t_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_std__vectorT_std__pairT_std__string_std__string_t_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__vectorT_std__shared_ptrT_SpecUtils__Measurement_const_t_t.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__vectorT_std__shared_ptrT_SpecUtils__Measurement_const_t_t.java new file mode 100644 index 00000000..2ecc0038 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__vectorT_std__shared_ptrT_SpecUtils__Measurement_const_t_t.java @@ -0,0 +1,29 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class SWIGTYPE_p_std__vectorT_std__shared_ptrT_SpecUtils__Measurement_const_t_t { + private transient long swigCPtr; + + protected SWIGTYPE_p_std__vectorT_std__shared_ptrT_SpecUtils__Measurement_const_t_t(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_std__vectorT_std__shared_ptrT_SpecUtils__Measurement_const_t_t() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_std__vectorT_std__shared_ptrT_SpecUtils__Measurement_const_t_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_std__vectorT_std__shared_ptrT_SpecUtils__Measurement_const_t_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__vectorT_std__shared_ptrT_SpecUtils__MultimediaData_const_t_t.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__vectorT_std__shared_ptrT_SpecUtils__MultimediaData_const_t_t.java new file mode 100644 index 00000000..3733a4cb --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_std__vectorT_std__shared_ptrT_SpecUtils__MultimediaData_const_t_t.java @@ -0,0 +1,29 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class SWIGTYPE_p_std__vectorT_std__shared_ptrT_SpecUtils__MultimediaData_const_t_t { + private transient long swigCPtr; + + protected SWIGTYPE_p_std__vectorT_std__shared_ptrT_SpecUtils__MultimediaData_const_t_t(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_std__vectorT_std__shared_ptrT_SpecUtils__MultimediaData_const_t_t() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_std__vectorT_std__shared_ptrT_SpecUtils__MultimediaData_const_t_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_std__vectorT_std__shared_ptrT_SpecUtils__MultimediaData_const_t_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_uint32_t.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_uint32_t.java new file mode 100644 index 00000000..a681ef30 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_uint32_t.java @@ -0,0 +1,29 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class SWIGTYPE_p_uint32_t { + private transient long swigCPtr; + + protected SWIGTYPE_p_uint32_t(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_uint32_t() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_uint32_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_uint32_t obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_unsigned_char.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_unsigned_char.java new file mode 100644 index 00000000..84af386a --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SWIGTYPE_p_unsigned_char.java @@ -0,0 +1,29 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class SWIGTYPE_p_unsigned_char { + private transient long swigCPtr; + + protected SWIGTYPE_p_unsigned_char(long cPtr, @SuppressWarnings("unused") boolean futureUse) { + swigCPtr = cPtr; + } + + protected SWIGTYPE_p_unsigned_char() { + swigCPtr = 0; + } + + protected static long getCPtr(SWIGTYPE_p_unsigned_char obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SWIGTYPE_p_unsigned_char obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SaveSpectrumAsType.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SaveSpectrumAsType.java new file mode 100644 index 00000000..6f97b677 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SaveSpectrumAsType.java @@ -0,0 +1,67 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public final class SaveSpectrumAsType { + public final static SaveSpectrumAsType Txt = new SaveSpectrumAsType("Txt"); + public final static SaveSpectrumAsType Csv = new SaveSpectrumAsType("Csv"); + public final static SaveSpectrumAsType Pcf = new SaveSpectrumAsType("Pcf"); + public final static SaveSpectrumAsType N42_2006 = new SaveSpectrumAsType("N42_2006"); + public final static SaveSpectrumAsType N42_2012 = new SaveSpectrumAsType("N42_2012"); + public final static SaveSpectrumAsType Chn = new SaveSpectrumAsType("Chn"); + public final static SaveSpectrumAsType SpcBinaryInt = new SaveSpectrumAsType("SpcBinaryInt"); + public final static SaveSpectrumAsType SpcBinaryFloat = new SaveSpectrumAsType("SpcBinaryFloat"); + public final static SaveSpectrumAsType SpcAscii = new SaveSpectrumAsType("SpcAscii"); + public final static SaveSpectrumAsType ExploraniumGr130v0 = new SaveSpectrumAsType("ExploraniumGr130v0"); + public final static SaveSpectrumAsType ExploraniumGr135v2 = new SaveSpectrumAsType("ExploraniumGr135v2"); + public final static SaveSpectrumAsType SpeIaea = new SaveSpectrumAsType("SpeIaea"); + public final static SaveSpectrumAsType Cnf = new SaveSpectrumAsType("Cnf"); + public final static SaveSpectrumAsType Tka = new SaveSpectrumAsType("Tka"); + public final static SaveSpectrumAsType HtmlD3 = new SaveSpectrumAsType("HtmlD3"); + public final static SaveSpectrumAsType NumTypes = new SaveSpectrumAsType("NumTypes"); + + public final int swigValue() { + return swigValue; + } + + public String toString() { + return swigName; + } + + public static SaveSpectrumAsType swigToEnum(int swigValue) { + if (swigValue < swigValues.length && swigValue >= 0 && swigValues[swigValue].swigValue == swigValue) + return swigValues[swigValue]; + for (int i = 0; i < swigValues.length; i++) + if (swigValues[i].swigValue == swigValue) + return swigValues[i]; + throw new IllegalArgumentException("No enum " + SaveSpectrumAsType.class + " with value " + swigValue); + } + + private SaveSpectrumAsType(String swigName) { + this.swigName = swigName; + this.swigValue = swigNext++; + } + + private SaveSpectrumAsType(String swigName, int swigValue) { + this.swigName = swigName; + this.swigValue = swigValue; + swigNext = swigValue+1; + } + + private SaveSpectrumAsType(String swigName, SaveSpectrumAsType swigEnum) { + this.swigName = swigName; + this.swigValue = swigEnum.swigValue; + swigNext = this.swigValue+1; + } + + private static SaveSpectrumAsType[] swigValues = { Txt, Csv, Pcf, N42_2006, N42_2012, Chn, SpcBinaryInt, SpcBinaryFloat, SpcAscii, ExploraniumGr130v0, ExploraniumGr135v2, SpeIaea, Cnf, Tka, HtmlD3, NumTypes }; + private static int swigNext = 0; + private final int swigValue; + private final String swigName; +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SourceType.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SourceType.java new file mode 100644 index 00000000..50acdf95 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SourceType.java @@ -0,0 +1,56 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public final class SourceType { + public final static SourceType IntrinsicActivity = new SourceType("IntrinsicActivity"); + public final static SourceType Calibration = new SourceType("Calibration"); + public final static SourceType Background = new SourceType("Background"); + public final static SourceType Foreground = new SourceType("Foreground"); + public final static SourceType Unknown = new SourceType("Unknown"); + + public final int swigValue() { + return swigValue; + } + + public String toString() { + return swigName; + } + + public static SourceType swigToEnum(int swigValue) { + if (swigValue < swigValues.length && swigValue >= 0 && swigValues[swigValue].swigValue == swigValue) + return swigValues[swigValue]; + for (int i = 0; i < swigValues.length; i++) + if (swigValues[i].swigValue == swigValue) + return swigValues[i]; + throw new IllegalArgumentException("No enum " + SourceType.class + " with value " + swigValue); + } + + private SourceType(String swigName) { + this.swigName = swigName; + this.swigValue = swigNext++; + } + + private SourceType(String swigName, int swigValue) { + this.swigName = swigName; + this.swigValue = swigValue; + swigNext = swigValue+1; + } + + private SourceType(String swigName, SourceType swigEnum) { + this.swigName = swigName; + this.swigValue = swigEnum.swigValue; + swigNext = this.swigValue+1; + } + + private static SourceType[] swigValues = { IntrinsicActivity, Calibration, Background, Foreground, Unknown }; + private static int swigNext = 0; + private final int swigValue; + private final String swigName; +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SpecFile.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SpecFile.java new file mode 100644 index 00000000..1e4f4421 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SpecFile.java @@ -0,0 +1,913 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class SpecFile { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected SpecFile(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(SpecFile obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(SpecFile obj) { + long ptr = 0; + if (obj != null) { + if (!obj.swigCMemOwn) + throw new RuntimeException("Cannot release ownership as memory is not owned"); + ptr = obj.swigCPtr; + obj.swigCMemOwn = false; + obj.delete(); + } + return ptr; + } + + @SuppressWarnings({"deprecation", "removal"}) + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + SpecUtilsSwigJNI.delete_SpecFile(swigCPtr); + } + swigCPtr = 0; + } + } + + public SpecFile() { + this(SpecUtilsSwigJNI.new_SpecFile__SWIG_0(), true); + } + + public SpecFile(SpecFile rhs) { + this(SpecUtilsSwigJNI.new_SpecFile__SWIG_1(SpecFile.getCPtr(rhs), rhs), true); + } + + public SpecFile operatorEqual(SpecFile rhs) { + return new SpecFile(SpecUtilsSwigJNI.SpecFile_operatorEqual(swigCPtr, this, SpecFile.getCPtr(rhs), rhs), false); + } + + public boolean load_file(String filename, ParserType parser_type, String file_ending_hint) { + return SpecUtilsSwigJNI.SpecFile_load_file(swigCPtr, this, filename, parser_type.swigValue(), file_ending_hint); + } + + public StringVector parse_warnings() { + return new StringVector(SpecUtilsSwigJNI.SpecFile_parse_warnings(swigCPtr, this), false); + } + + public boolean modified() { + return SpecUtilsSwigJNI.SpecFile_modified(swigCPtr, this); + } + + public void reset_modified() { + SpecUtilsSwigJNI.SpecFile_reset_modified(swigCPtr, this); + } + + public boolean modified_since_decode() { + return SpecUtilsSwigJNI.SpecFile_modified_since_decode(swigCPtr, this); + } + + public void reset_modified_since_decode() { + SpecUtilsSwigJNI.SpecFile_reset_modified_since_decode(swigCPtr, this); + } + + public float gamma_live_time() { + return SpecUtilsSwigJNI.SpecFile_gamma_live_time(swigCPtr, this); + } + + public float gamma_real_time() { + return SpecUtilsSwigJNI.SpecFile_gamma_real_time(swigCPtr, this); + } + + public double gamma_count_sum() { + return SpecUtilsSwigJNI.SpecFile_gamma_count_sum(swigCPtr, this); + } + + public double neutron_counts_sum() { + return SpecUtilsSwigJNI.SpecFile_neutron_counts_sum(swigCPtr, this); + } + + public String filename() { + return SpecUtilsSwigJNI.SpecFile_filename(swigCPtr, this); + } + + public StringVector detector_names() { + return new StringVector(SpecUtilsSwigJNI.SpecFile_detector_names(swigCPtr, this), false); + } + + public IntVector detector_numbers() { + return new IntVector(SpecUtilsSwigJNI.SpecFile_detector_numbers(swigCPtr, this), false); + } + + public StringVector gamma_detector_names() { + return new StringVector(SpecUtilsSwigJNI.SpecFile_gamma_detector_names(swigCPtr, this), false); + } + + public StringVector neutron_detector_names() { + return new StringVector(SpecUtilsSwigJNI.SpecFile_neutron_detector_names(swigCPtr, this), false); + } + + public String uuid() { + return SpecUtilsSwigJNI.SpecFile_uuid(swigCPtr, this); + } + + public StringVector remarks() { + return new StringVector(SpecUtilsSwigJNI.SpecFile_remarks(swigCPtr, this), false); + } + + public int lane_number() { + return SpecUtilsSwigJNI.SpecFile_lane_number(swigCPtr, this); + } + + public String measurement_location_name() { + return SpecUtilsSwigJNI.SpecFile_measurement_location_name(swigCPtr, this); + } + + public String inspection() { + return SpecUtilsSwigJNI.SpecFile_inspection(swigCPtr, this); + } + + public String measurement_operator() { + return SpecUtilsSwigJNI.SpecFile_measurement_operator(swigCPtr, this); + } + + public SWIGTYPE_p_std__setT_int_t sample_numbers() { + return new SWIGTYPE_p_std__setT_int_t(SpecUtilsSwigJNI.SpecFile_sample_numbers(swigCPtr, this), false); + } + + public long num_measurements() { + return SpecUtilsSwigJNI.SpecFile_num_measurements(swigCPtr, this); + } + + public DetectorType detector_type() { + return DetectorType.swigToEnum(SpecUtilsSwigJNI.SpecFile_detector_type(swigCPtr, this)); + } + + public String instrument_type() { + return SpecUtilsSwigJNI.SpecFile_instrument_type(swigCPtr, this); + } + + public String manufacturer() { + return SpecUtilsSwigJNI.SpecFile_manufacturer(swigCPtr, this); + } + + public String instrument_model() { + return SpecUtilsSwigJNI.SpecFile_instrument_model(swigCPtr, this); + } + + public String instrument_id() { + return SpecUtilsSwigJNI.SpecFile_instrument_id(swigCPtr, this); + } + + public SWIGTYPE_p_std__vectorT_std__shared_ptrT_SpecUtils__Measurement_const_t_t measurements() { + return new SWIGTYPE_p_std__vectorT_std__shared_ptrT_SpecUtils__Measurement_const_t_t(SpecUtilsSwigJNI.SpecFile_measurements(swigCPtr, this), true); + } + + public Measurement measurement(long num) { + long cPtr = SpecUtilsSwigJNI.SpecFile_measurement__SWIG_0(swigCPtr, this, num); + return (cPtr == 0) ? null : new Measurement(cPtr, true); + } + + public SWIGTYPE_p_std__shared_ptrT_SpecUtils__DetectorAnalysis_const_t detectors_analysis() { + return new SWIGTYPE_p_std__shared_ptrT_SpecUtils__DetectorAnalysis_const_t(SpecUtilsSwigJNI.SpecFile_detectors_analysis(swigCPtr, this), true); + } + + public SWIGTYPE_p_std__vectorT_std__shared_ptrT_SpecUtils__MultimediaData_const_t_t multimedia_data() { + return new SWIGTYPE_p_std__vectorT_std__shared_ptrT_SpecUtils__MultimediaData_const_t_t(SpecUtilsSwigJNI.SpecFile_multimedia_data(swigCPtr, this), false); + } + + public boolean has_gps_info() { + return SpecUtilsSwigJNI.SpecFile_has_gps_info(swigCPtr, this); + } + + public double mean_latitude() { + return SpecUtilsSwigJNI.SpecFile_mean_latitude(swigCPtr, this); + } + + public double mean_longitude() { + return SpecUtilsSwigJNI.SpecFile_mean_longitude(swigCPtr, this); + } + + public boolean passthrough() { + return SpecUtilsSwigJNI.SpecFile_passthrough(swigCPtr, this); + } + + public boolean contains_derived_data() { + return SpecUtilsSwigJNI.SpecFile_contains_derived_data(swigCPtr, this); + } + + public boolean contains_non_derived_data() { + return SpecUtilsSwigJNI.SpecFile_contains_non_derived_data(swigCPtr, this); + } + + public void set_filename(String n) { + SpecUtilsSwigJNI.SpecFile_set_filename(swigCPtr, this, n); + } + + public void set_remarks(StringVector n) { + SpecUtilsSwigJNI.SpecFile_set_remarks__SWIG_0(swigCPtr, this, StringVector.getCPtr(n), n); + } + + public void add_remark(String remark) { + SpecUtilsSwigJNI.SpecFile_add_remark(swigCPtr, this, remark); + } + + public void set_parse_warnings(StringVector warnings) { + SpecUtilsSwigJNI.SpecFile_set_parse_warnings(swigCPtr, this, StringVector.getCPtr(warnings), warnings); + } + + public void set_uuid(String n) { + SpecUtilsSwigJNI.SpecFile_set_uuid(swigCPtr, this, n); + } + + public void set_lane_number(int num) { + SpecUtilsSwigJNI.SpecFile_set_lane_number(swigCPtr, this, num); + } + + public void set_measurement_location_name(String n) { + SpecUtilsSwigJNI.SpecFile_set_measurement_location_name(swigCPtr, this, n); + } + + public void set_inspection(String n) { + SpecUtilsSwigJNI.SpecFile_set_inspection(swigCPtr, this, n); + } + + public void set_instrument_type(String n) { + SpecUtilsSwigJNI.SpecFile_set_instrument_type(swigCPtr, this, n); + } + + public void set_detector_type(DetectorType type) { + SpecUtilsSwigJNI.SpecFile_set_detector_type(swigCPtr, this, type.swigValue()); + } + + public void set_manufacturer(String n) { + SpecUtilsSwigJNI.SpecFile_set_manufacturer(swigCPtr, this, n); + } + + public void set_instrument_model(String n) { + SpecUtilsSwigJNI.SpecFile_set_instrument_model(swigCPtr, this, n); + } + + public void set_instrument_id(String n) { + SpecUtilsSwigJNI.SpecFile_set_instrument_id(swigCPtr, this, n); + } + + public void set_live_time(float lt, Measurement measurement) { + SpecUtilsSwigJNI.SpecFile_set_live_time(swigCPtr, this, lt, Measurement.getCPtr(measurement), measurement); + } + + public void set_real_time(float rt, Measurement measurement) { + SpecUtilsSwigJNI.SpecFile_set_real_time(swigCPtr, this, rt, Measurement.getCPtr(measurement), measurement); + } + + public void set_start_time(SWIGTYPE_p_std__chrono__time_pointT_std__chrono__system_clock_std__chrono__microseconds_t timestamp, Measurement measurement) { + SpecUtilsSwigJNI.SpecFile_set_start_time(swigCPtr, this, SWIGTYPE_p_std__chrono__time_pointT_std__chrono__system_clock_std__chrono__microseconds_t.getCPtr(timestamp), Measurement.getCPtr(measurement), measurement); + } + + public void set_remarks(StringVector remarks, Measurement measurement) { + SpecUtilsSwigJNI.SpecFile_set_remarks__SWIG_1(swigCPtr, this, StringVector.getCPtr(remarks), remarks, Measurement.getCPtr(measurement), measurement); + } + + public void set_source_type(SourceType type, Measurement measurement) { + SpecUtilsSwigJNI.SpecFile_set_source_type(swigCPtr, this, type.swigValue(), Measurement.getCPtr(measurement), measurement); + } + + public void set_position(double longitude, double latitude, SWIGTYPE_p_std__chrono__time_pointT_std__chrono__system_clock_std__chrono__microseconds_t position_time, Measurement measurement) { + SpecUtilsSwigJNI.SpecFile_set_position(swigCPtr, this, longitude, latitude, SWIGTYPE_p_std__chrono__time_pointT_std__chrono__system_clock_std__chrono__microseconds_t.getCPtr(position_time), Measurement.getCPtr(measurement), measurement); + } + + public void set_title(String title, Measurement measurement) { + SpecUtilsSwigJNI.SpecFile_set_title(swigCPtr, this, title, Measurement.getCPtr(measurement), measurement); + } + + public void set_contained_neutrons(boolean contained, float counts, Measurement measurement, float neutron_live_time) { + SpecUtilsSwigJNI.SpecFile_set_contained_neutrons(swigCPtr, this, contained, counts, Measurement.getCPtr(measurement), measurement, neutron_live_time); + } + + public void set_detectors_analysis(DetectorAnalysis ana) { + SpecUtilsSwigJNI.SpecFile_set_detectors_analysis(swigCPtr, this, DetectorAnalysis.getCPtr(ana), ana); + } + + public void change_detector_name(String original_name, String new_name) { + SpecUtilsSwigJNI.SpecFile_change_detector_name(swigCPtr, this, original_name, new_name); + } + + public void change_sample_numbers(SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_t from_to_sample_nums) { + SpecUtilsSwigJNI.SpecFile_change_sample_numbers(swigCPtr, this, SWIGTYPE_p_std__vectorT_std__pairT_int_int_t_t.getCPtr(from_to_sample_nums)); + } + + public void add_measurement(Measurement meas, boolean doCleanup) { + SpecUtilsSwigJNI.SpecFile_add_measurement(swigCPtr, this, Measurement.getCPtr(meas), meas, doCleanup); + } + + public void remove_measurement(Measurement meas, boolean doCleanup) { + SpecUtilsSwigJNI.SpecFile_remove_measurement(swigCPtr, this, Measurement.getCPtr(meas), meas, doCleanup); + } + + public void remove_measurements(SWIGTYPE_p_std__vectorT_std__shared_ptrT_SpecUtils__Measurement_const_t_t meas) { + SpecUtilsSwigJNI.SpecFile_remove_measurements(swigCPtr, this, SWIGTYPE_p_std__vectorT_std__shared_ptrT_SpecUtils__Measurement_const_t_t.getCPtr(meas)); + } + + public void clear_multimedia_data() { + SpecUtilsSwigJNI.SpecFile_clear_multimedia_data(swigCPtr, this); + } + + public void add_multimedia_data(MultimediaData data) { + SpecUtilsSwigJNI.SpecFile_add_multimedia_data(swigCPtr, this, MultimediaData.getCPtr(data), data); + } + + public void set_multimedia_data(SWIGTYPE_p_std__vectorT_std__shared_ptrT_SpecUtils__MultimediaData_const_t_t data) { + SpecUtilsSwigJNI.SpecFile_set_multimedia_data(swigCPtr, this, SWIGTYPE_p_std__vectorT_std__shared_ptrT_SpecUtils__MultimediaData_const_t_t.getCPtr(data)); + } + + public long combine_gamma_channels(long ncombine, long nchannels) { + return SpecUtilsSwigJNI.SpecFile_combine_gamma_channels__SWIG_0(swigCPtr, this, ncombine, nchannels); + } + + public void combine_gamma_channels(long ncombine, Measurement m) { + SpecUtilsSwigJNI.SpecFile_combine_gamma_channels__SWIG_1(swigCPtr, this, ncombine, Measurement.getCPtr(m), m); + } + + public long truncate_gamma_channels(long keep_first_channel, long keep_last_channel, long nchannels, boolean keep_under_over_flow) { + return SpecUtilsSwigJNI.SpecFile_truncate_gamma_channels__SWIG_0(swigCPtr, this, keep_first_channel, keep_last_channel, nchannels, keep_under_over_flow); + } + + public void truncate_gamma_channels(long keep_first_channel, long keep_last_channel, boolean keep_under_over_flow, Measurement m) { + SpecUtilsSwigJNI.SpecFile_truncate_gamma_channels__SWIG_1(swigCPtr, this, keep_first_channel, keep_last_channel, keep_under_over_flow, Measurement.getCPtr(m), m); + } + + public int occupancy_number_from_remarks() { + return SpecUtilsSwigJNI.SpecFile_occupancy_number_from_remarks(swigCPtr, this); + } + + public SWIGTYPE_p_std__vectorT_std__shared_ptrT_SpecUtils__Measurement_const_t_t sample_measurements(int sample_number) { + return new SWIGTYPE_p_std__vectorT_std__shared_ptrT_SpecUtils__Measurement_const_t_t(SpecUtilsSwigJNI.SpecFile_sample_measurements(swigCPtr, this, sample_number), true); + } + + public Measurement measurement(int sample_number, String det_name) { + long cPtr = SpecUtilsSwigJNI.SpecFile_measurement__SWIG_1(swigCPtr, this, sample_number, det_name); + return (cPtr == 0) ? null : new Measurement(cPtr, true); + } + + public Measurement measurement(int sample_number, int detector_number) { + long cPtr = SpecUtilsSwigJNI.SpecFile_measurement__SWIG_2(swigCPtr, this, sample_number, detector_number); + return (cPtr == 0) ? null : new Measurement(cPtr, true); + } + + public SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_const_t suggested_sum_energy_calibration(SWIGTYPE_p_std__setT_int_t sample_numbers, StringVector detector_names) { + return new SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_const_t(SpecUtilsSwigJNI.SpecFile_suggested_sum_energy_calibration(swigCPtr, this, SWIGTYPE_p_std__setT_int_t.getCPtr(sample_numbers), StringVector.getCPtr(detector_names), detector_names), true); + } + + public Measurement sum_measurements(SWIGTYPE_p_std__setT_int_t sample_numbers, StringVector detector_names, SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_const_t energy_cal) { + long cPtr = SpecUtilsSwigJNI.SpecFile_sum_measurements(swigCPtr, this, SWIGTYPE_p_std__setT_int_t.getCPtr(sample_numbers), StringVector.getCPtr(detector_names), detector_names, SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_const_t.getCPtr(energy_cal)); + return (cPtr == 0) ? null : new Measurement(cPtr, true); + } + + public long memmorysize() { + return SpecUtilsSwigJNI.SpecFile_memmorysize(swigCPtr, this); + } + + public SWIGTYPE_p_std__setT_size_t_t gamma_channel_counts() { + return new SWIGTYPE_p_std__setT_size_t_t(SpecUtilsSwigJNI.SpecFile_gamma_channel_counts(swigCPtr, this), true); + } + + public long num_gamma_channels() { + return SpecUtilsSwigJNI.SpecFile_num_gamma_channels(swigCPtr, this); + } + + public long keep_n_bin_spectra_only(long nbin) { + return SpecUtilsSwigJNI.SpecFile_keep_n_bin_spectra_only(swigCPtr, this, nbin); + } + + public boolean contained_neutron() { + return SpecUtilsSwigJNI.SpecFile_contained_neutron(swigCPtr, this); + } + + public SWIGTYPE_p_std__setT_std__string_t energy_cal_variants() { + return new SWIGTYPE_p_std__setT_std__string_t(SpecUtilsSwigJNI.SpecFile_energy_cal_variants(swigCPtr, this), true); + } + + public long keep_energy_cal_variants(SWIGTYPE_p_std__setT_std__string_t variants) { + return SpecUtilsSwigJNI.SpecFile_keep_energy_cal_variants(swigCPtr, this, SWIGTYPE_p_std__setT_std__string_t.getCPtr(variants)); + } + + public long keep_derived_data_variant(SpecFile.DerivedVariantToKeep tokeep) { + return SpecUtilsSwigJNI.SpecFile_keep_derived_data_variant(swigCPtr, this, tokeep.swigValue()); + } + + public long remove_detectors_data(SWIGTYPE_p_std__setT_std__string_t dets_to_remove) { + return SpecUtilsSwigJNI.SpecFile_remove_detectors_data(swigCPtr, this, SWIGTYPE_p_std__setT_std__string_t.getCPtr(dets_to_remove)); + } + + public long remove_neutron_measurements() { + return SpecUtilsSwigJNI.SpecFile_remove_neutron_measurements(swigCPtr, this); + } + + public int background_sample_number() { + return SpecUtilsSwigJNI.SpecFile_background_sample_number(swigCPtr, this); + } + + public String generate_psuedo_uuid() { + return SpecUtilsSwigJNI.SpecFile_generate_psuedo_uuid(swigCPtr, this); + } + + public void reset() { + SpecUtilsSwigJNI.SpecFile_reset(swigCPtr, this); + } + + public boolean load_N42_file(String filename) { + return SpecUtilsSwigJNI.SpecFile_load_N42_file(swigCPtr, this, filename); + } + + public boolean load_pcf_file(String filename) { + return SpecUtilsSwigJNI.SpecFile_load_pcf_file(swigCPtr, this, filename); + } + + public boolean load_spc_file(String filename) { + return SpecUtilsSwigJNI.SpecFile_load_spc_file(swigCPtr, this, filename); + } + + public boolean load_chn_file(String filename) { + return SpecUtilsSwigJNI.SpecFile_load_chn_file(swigCPtr, this, filename); + } + + public boolean load_iaea_file(String filename) { + return SpecUtilsSwigJNI.SpecFile_load_iaea_file(swigCPtr, this, filename); + } + + public boolean load_binary_exploranium_file(String file_name) { + return SpecUtilsSwigJNI.SpecFile_load_binary_exploranium_file(swigCPtr, this, file_name); + } + + public boolean load_micro_raider_file(String filename) { + return SpecUtilsSwigJNI.SpecFile_load_micro_raider_file(swigCPtr, this, filename); + } + + public boolean load_txt_or_csv_file(String filename) { + return SpecUtilsSwigJNI.SpecFile_load_txt_or_csv_file(swigCPtr, this, filename); + } + + public boolean load_cnf_file(String filename) { + return SpecUtilsSwigJNI.SpecFile_load_cnf_file(swigCPtr, this, filename); + } + + public boolean load_tracs_mps_file(String filename) { + return SpecUtilsSwigJNI.SpecFile_load_tracs_mps_file(swigCPtr, this, filename); + } + + public boolean load_aram_file(String filename) { + return SpecUtilsSwigJNI.SpecFile_load_aram_file(swigCPtr, this, filename); + } + + public boolean load_spectroscopic_daily_file(String filename) { + return SpecUtilsSwigJNI.SpecFile_load_spectroscopic_daily_file(swigCPtr, this, filename); + } + + public boolean load_amptek_file(String filename) { + return SpecUtilsSwigJNI.SpecFile_load_amptek_file(swigCPtr, this, filename); + } + + public boolean load_ortec_listmode_file(String filename) { + return SpecUtilsSwigJNI.SpecFile_load_ortec_listmode_file(swigCPtr, this, filename); + } + + public boolean load_lsrm_spe_file(String filename) { + return SpecUtilsSwigJNI.SpecFile_load_lsrm_spe_file(swigCPtr, this, filename); + } + + public boolean load_tka_file(String filename) { + return SpecUtilsSwigJNI.SpecFile_load_tka_file(swigCPtr, this, filename); + } + + public boolean load_multiact_file(String filename) { + return SpecUtilsSwigJNI.SpecFile_load_multiact_file(swigCPtr, this, filename); + } + + public boolean load_phd_file(String filename) { + return SpecUtilsSwigJNI.SpecFile_load_phd_file(swigCPtr, this, filename); + } + + public boolean load_lzs_file(String filename) { + return SpecUtilsSwigJNI.SpecFile_load_lzs_file(swigCPtr, this, filename); + } + + public boolean load_radiacode_file(String filename) { + return SpecUtilsSwigJNI.SpecFile_load_radiacode_file(swigCPtr, this, filename); + } + + public boolean load_xml_scan_data_file(String filename) { + return SpecUtilsSwigJNI.SpecFile_load_xml_scan_data_file(swigCPtr, this, filename); + } + + public boolean load_json_file(String filename) { + return SpecUtilsSwigJNI.SpecFile_load_json_file(swigCPtr, this, filename); + } + + public boolean load_caen_gxml_file(String filename) { + return SpecUtilsSwigJNI.SpecFile_load_caen_gxml_file(swigCPtr, this, filename); + } + + public boolean load_from_N42(SWIGTYPE_p_std__istream istr) { + return SpecUtilsSwigJNI.SpecFile_load_from_N42(swigCPtr, this, SWIGTYPE_p_std__istream.getCPtr(istr)); + } + + public boolean load_N42_from_data(String data) { + return SpecUtilsSwigJNI.SpecFile_load_N42_from_data__SWIG_0(swigCPtr, this, data); + } + + public boolean load_N42_from_data(String data, String data_end) { + return SpecUtilsSwigJNI.SpecFile_load_N42_from_data__SWIG_1(swigCPtr, this, data, data_end); + } + + public boolean load_from_iaea_spc(SWIGTYPE_p_std__istream input) { + return SpecUtilsSwigJNI.SpecFile_load_from_iaea_spc(swigCPtr, this, SWIGTYPE_p_std__istream.getCPtr(input)); + } + + public boolean load_from_binary_spc(SWIGTYPE_p_std__istream input) { + return SpecUtilsSwigJNI.SpecFile_load_from_binary_spc(swigCPtr, this, SWIGTYPE_p_std__istream.getCPtr(input)); + } + + public boolean load_from_N42_document(SWIGTYPE_p_rapidxml__xml_nodeT_char_t document_node) { + return SpecUtilsSwigJNI.SpecFile_load_from_N42_document(swigCPtr, this, SWIGTYPE_p_rapidxml__xml_nodeT_char_t.getCPtr(document_node)); + } + + public boolean load_from_micro_raider_from_data(String data) { + return SpecUtilsSwigJNI.SpecFile_load_from_micro_raider_from_data(swigCPtr, this, data); + } + + public boolean load_from_binary_exploranium(SWIGTYPE_p_std__istream istr) { + return SpecUtilsSwigJNI.SpecFile_load_from_binary_exploranium(swigCPtr, this, SWIGTYPE_p_std__istream.getCPtr(istr)); + } + + public boolean load_from_pcf(SWIGTYPE_p_std__istream istr) { + return SpecUtilsSwigJNI.SpecFile_load_from_pcf(swigCPtr, this, SWIGTYPE_p_std__istream.getCPtr(istr)); + } + + public boolean load_from_txt_or_csv(SWIGTYPE_p_std__istream istr) { + return SpecUtilsSwigJNI.SpecFile_load_from_txt_or_csv(swigCPtr, this, SWIGTYPE_p_std__istream.getCPtr(istr)); + } + + public boolean load_from_Gr135_txt(SWIGTYPE_p_std__istream istr) { + return SpecUtilsSwigJNI.SpecFile_load_from_Gr135_txt(swigCPtr, this, SWIGTYPE_p_std__istream.getCPtr(istr)); + } + + public boolean load_from_spectroscopic_daily_file(SWIGTYPE_p_std__istream input) { + return SpecUtilsSwigJNI.SpecFile_load_from_spectroscopic_daily_file(swigCPtr, this, SWIGTYPE_p_std__istream.getCPtr(input)); + } + + public boolean load_from_srpm210_csv(SWIGTYPE_p_std__istream input) { + return SpecUtilsSwigJNI.SpecFile_load_from_srpm210_csv(swigCPtr, this, SWIGTYPE_p_std__istream.getCPtr(input)); + } + + public boolean load_from_D3S_raw(SWIGTYPE_p_std__istream input) { + return SpecUtilsSwigJNI.SpecFile_load_from_D3S_raw(swigCPtr, this, SWIGTYPE_p_std__istream.getCPtr(input)); + } + + public boolean load_from_amptek_mca(SWIGTYPE_p_std__istream input) { + return SpecUtilsSwigJNI.SpecFile_load_from_amptek_mca(swigCPtr, this, SWIGTYPE_p_std__istream.getCPtr(input)); + } + + public boolean load_from_ortec_listmode(SWIGTYPE_p_std__istream input) { + return SpecUtilsSwigJNI.SpecFile_load_from_ortec_listmode(swigCPtr, this, SWIGTYPE_p_std__istream.getCPtr(input)); + } + + public boolean load_from_lsrm_spe(SWIGTYPE_p_std__istream input) { + return SpecUtilsSwigJNI.SpecFile_load_from_lsrm_spe(swigCPtr, this, SWIGTYPE_p_std__istream.getCPtr(input)); + } + + public boolean load_from_tka(SWIGTYPE_p_std__istream input) { + return SpecUtilsSwigJNI.SpecFile_load_from_tka(swigCPtr, this, SWIGTYPE_p_std__istream.getCPtr(input)); + } + + public boolean load_from_multiact(SWIGTYPE_p_std__istream input) { + return SpecUtilsSwigJNI.SpecFile_load_from_multiact(swigCPtr, this, SWIGTYPE_p_std__istream.getCPtr(input)); + } + + public boolean load_from_phd(SWIGTYPE_p_std__istream input) { + return SpecUtilsSwigJNI.SpecFile_load_from_phd(swigCPtr, this, SWIGTYPE_p_std__istream.getCPtr(input)); + } + + public boolean load_from_lzs(SWIGTYPE_p_std__istream input) { + return SpecUtilsSwigJNI.SpecFile_load_from_lzs(swigCPtr, this, SWIGTYPE_p_std__istream.getCPtr(input)); + } + + public boolean load_from_radiacode(SWIGTYPE_p_std__istream input) { + return SpecUtilsSwigJNI.SpecFile_load_from_radiacode(swigCPtr, this, SWIGTYPE_p_std__istream.getCPtr(input)); + } + + public boolean load_from_radiacode_spectrogram(SWIGTYPE_p_std__istream input) { + return SpecUtilsSwigJNI.SpecFile_load_from_radiacode_spectrogram(swigCPtr, this, SWIGTYPE_p_std__istream.getCPtr(input)); + } + + public boolean load_from_xml_scan_data(SWIGTYPE_p_std__istream input) { + return SpecUtilsSwigJNI.SpecFile_load_from_xml_scan_data(swigCPtr, this, SWIGTYPE_p_std__istream.getCPtr(input)); + } + + public boolean load_from_iaea(SWIGTYPE_p_std__istream istr) { + return SpecUtilsSwigJNI.SpecFile_load_from_iaea(swigCPtr, this, SWIGTYPE_p_std__istream.getCPtr(istr)); + } + + public boolean load_from_chn(SWIGTYPE_p_std__istream input) { + return SpecUtilsSwigJNI.SpecFile_load_from_chn(swigCPtr, this, SWIGTYPE_p_std__istream.getCPtr(input)); + } + + public boolean load_from_cnf(SWIGTYPE_p_std__istream input) { + return SpecUtilsSwigJNI.SpecFile_load_from_cnf(swigCPtr, this, SWIGTYPE_p_std__istream.getCPtr(input)); + } + + public boolean load_from_tracs_mps(SWIGTYPE_p_std__istream input) { + return SpecUtilsSwigJNI.SpecFile_load_from_tracs_mps(swigCPtr, this, SWIGTYPE_p_std__istream.getCPtr(input)); + } + + public boolean load_from_aram(SWIGTYPE_p_std__istream input) { + return SpecUtilsSwigJNI.SpecFile_load_from_aram(swigCPtr, this, SWIGTYPE_p_std__istream.getCPtr(input)); + } + + public boolean load_from_json(SWIGTYPE_p_std__istream input) { + return SpecUtilsSwigJNI.SpecFile_load_from_json(swigCPtr, this, SWIGTYPE_p_std__istream.getCPtr(input)); + } + + public boolean load_from_caen_gxml(SWIGTYPE_p_std__istream input) { + return SpecUtilsSwigJNI.SpecFile_load_from_caen_gxml(swigCPtr, this, SWIGTYPE_p_std__istream.getCPtr(input)); + } + + public void cleanup_after_load(long flags) { + SpecUtilsSwigJNI.SpecFile_cleanup_after_load__SWIG_0(swigCPtr, this, flags); + } + + public void cleanup_after_load() { + SpecUtilsSwigJNI.SpecFile_cleanup_after_load__SWIG_1(swigCPtr, this); + } + + public void recalc_total_counts() { + SpecUtilsSwigJNI.SpecFile_recalc_total_counts(swigCPtr, this); + } + + public void merge_neutron_meas_into_gamma_meas() { + SpecUtilsSwigJNI.SpecFile_merge_neutron_meas_into_gamma_meas(swigCPtr, this); + } + + public void rebin_measurement(SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_const_t cal, Measurement measurement) { + SpecUtilsSwigJNI.SpecFile_rebin_measurement(swigCPtr, this, SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_const_t.getCPtr(cal), Measurement.getCPtr(measurement), measurement); + } + + public void rebin_all_measurements(SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_const_t cal) { + SpecUtilsSwigJNI.SpecFile_rebin_all_measurements(swigCPtr, this, SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_const_t.getCPtr(cal)); + } + + public void set_energy_calibration(SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_const_t cal, Measurement measurement) { + SpecUtilsSwigJNI.SpecFile_set_energy_calibration__SWIG_0(swigCPtr, this, SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_const_t.getCPtr(cal), Measurement.getCPtr(measurement), measurement); + } + + public long set_energy_calibration(SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_const_t cal, SWIGTYPE_p_std__setT_int_t sample_numbers, StringVector detector_names) { + return SpecUtilsSwigJNI.SpecFile_set_energy_calibration__SWIG_1(swigCPtr, this, SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_const_t.getCPtr(cal), SWIGTYPE_p_std__setT_int_t.getCPtr(sample_numbers), StringVector.getCPtr(detector_names), detector_names); + } + + public void set_energy_calibration_from_CALp_file(SWIGTYPE_p_std__istream input) { + SpecUtilsSwigJNI.SpecFile_set_energy_calibration_from_CALp_file(swigCPtr, this, SWIGTYPE_p_std__istream.getCPtr(input)); + } + + public SWIGTYPE_p_std__setT_int_t detector_names_to_numbers(StringVector det_names) { + return new SWIGTYPE_p_std__setT_int_t(SpecUtilsSwigJNI.SpecFile_detector_names_to_numbers(swigCPtr, this, StringVector.getCPtr(det_names), det_names), true); + } + + public void write_to_file(String filename, SaveSpectrumAsType format) { + SpecUtilsSwigJNI.SpecFile_write_to_file__SWIG_0(swigCPtr, this, filename, format.swigValue()); + } + + public void write_to_file(String filename, SWIGTYPE_p_std__setT_int_t sample_nums, SWIGTYPE_p_std__setT_int_t det_nums, SaveSpectrumAsType format) { + SpecUtilsSwigJNI.SpecFile_write_to_file__SWIG_1(swigCPtr, this, filename, SWIGTYPE_p_std__setT_int_t.getCPtr(sample_nums), SWIGTYPE_p_std__setT_int_t.getCPtr(det_nums), format.swigValue()); + } + + public void write_to_file(String filename, IntVector sample_nums, IntVector det_nums, SaveSpectrumAsType format) { + SpecUtilsSwigJNI.SpecFile_write_to_file__SWIG_2(swigCPtr, this, filename, IntVector.getCPtr(sample_nums), sample_nums, IntVector.getCPtr(det_nums), det_nums, format.swigValue()); + } + + public void write_to_file(String filename, SWIGTYPE_p_std__setT_int_t sample_nums, StringVector det_names, SaveSpectrumAsType format) { + SpecUtilsSwigJNI.SpecFile_write_to_file__SWIG_3(swigCPtr, this, filename, SWIGTYPE_p_std__setT_int_t.getCPtr(sample_nums), StringVector.getCPtr(det_names), det_names, format.swigValue()); + } + + public void write(SWIGTYPE_p_std__ostream strm, SWIGTYPE_p_std__setT_int_t sample_nums, SWIGTYPE_p_std__setT_int_t det_nums, SaveSpectrumAsType format) { + SpecUtilsSwigJNI.SpecFile_write__SWIG_0(swigCPtr, this, SWIGTYPE_p_std__ostream.getCPtr(strm), SWIGTYPE_p_std__setT_int_t.getCPtr(sample_nums), SWIGTYPE_p_std__setT_int_t.getCPtr(det_nums), format.swigValue()); + } + + public void write(SWIGTYPE_p_std__ostream strm, SWIGTYPE_p_std__setT_int_t sample_nums, StringVector det_names, SaveSpectrumAsType format) { + SpecUtilsSwigJNI.SpecFile_write__SWIG_1(swigCPtr, this, SWIGTYPE_p_std__ostream.getCPtr(strm), SWIGTYPE_p_std__setT_int_t.getCPtr(sample_nums), StringVector.getCPtr(det_names), det_names, format.swigValue()); + } + + public boolean write_pcf(SWIGTYPE_p_std__ostream ostr) { + return SpecUtilsSwigJNI.SpecFile_write_pcf(swigCPtr, this, SWIGTYPE_p_std__ostream.getCPtr(ostr)); + } + + public boolean write_2006_N42(SWIGTYPE_p_std__ostream ostr) { + return SpecUtilsSwigJNI.SpecFile_write_2006_N42(swigCPtr, this, SWIGTYPE_p_std__ostream.getCPtr(ostr)); + } + + public boolean write_csv(SWIGTYPE_p_std__ostream ostr) { + return SpecUtilsSwigJNI.SpecFile_write_csv(swigCPtr, this, SWIGTYPE_p_std__ostream.getCPtr(ostr)); + } + + public boolean write_txt(SWIGTYPE_p_std__ostream ostr) { + return SpecUtilsSwigJNI.SpecFile_write_txt(swigCPtr, this, SWIGTYPE_p_std__ostream.getCPtr(ostr)); + } + + public boolean write_integer_chn(SWIGTYPE_p_std__ostream ostr, SWIGTYPE_p_std__setT_int_t sample_nums, SWIGTYPE_p_std__setT_int_t det_nums) { + return SpecUtilsSwigJNI.SpecFile_write_integer_chn__SWIG_0(swigCPtr, this, SWIGTYPE_p_std__ostream.getCPtr(ostr), SWIGTYPE_p_std__setT_int_t.getCPtr(sample_nums), SWIGTYPE_p_std__setT_int_t.getCPtr(det_nums)); + } + + public boolean write_integer_chn(SWIGTYPE_p_std__ostream ostr, SWIGTYPE_p_std__setT_int_t sample_nums, StringVector det_names) { + return SpecUtilsSwigJNI.SpecFile_write_integer_chn__SWIG_1(swigCPtr, this, SWIGTYPE_p_std__ostream.getCPtr(ostr), SWIGTYPE_p_std__setT_int_t.getCPtr(sample_nums), StringVector.getCPtr(det_names), det_names); + } + + public boolean write_binary_spc(SWIGTYPE_p_std__ostream ostr, SpecFile.SpcBinaryType type, SWIGTYPE_p_std__setT_int_t sample_nums, SWIGTYPE_p_std__setT_int_t det_nums) { + return SpecUtilsSwigJNI.SpecFile_write_binary_spc(swigCPtr, this, SWIGTYPE_p_std__ostream.getCPtr(ostr), type.swigValue(), SWIGTYPE_p_std__setT_int_t.getCPtr(sample_nums), SWIGTYPE_p_std__setT_int_t.getCPtr(det_nums)); + } + + public boolean write_ascii_spc(SWIGTYPE_p_std__ostream output, SWIGTYPE_p_std__setT_int_t sample_nums, SWIGTYPE_p_std__setT_int_t det_nums) { + return SpecUtilsSwigJNI.SpecFile_write_ascii_spc(swigCPtr, this, SWIGTYPE_p_std__ostream.getCPtr(output), SWIGTYPE_p_std__setT_int_t.getCPtr(sample_nums), SWIGTYPE_p_std__setT_int_t.getCPtr(det_nums)); + } + + public boolean write_binary_exploranium_gr130v0(SWIGTYPE_p_std__ostream output) { + return SpecUtilsSwigJNI.SpecFile_write_binary_exploranium_gr130v0(swigCPtr, this, SWIGTYPE_p_std__ostream.getCPtr(output)); + } + + public boolean write_binary_exploranium_gr135v2(SWIGTYPE_p_std__ostream output) { + return SpecUtilsSwigJNI.SpecFile_write_binary_exploranium_gr135v2(swigCPtr, this, SWIGTYPE_p_std__ostream.getCPtr(output)); + } + + public boolean write_iaea_spe(SWIGTYPE_p_std__ostream output, SWIGTYPE_p_std__setT_int_t sample_nums, SWIGTYPE_p_std__setT_int_t det_nums) { + return SpecUtilsSwigJNI.SpecFile_write_iaea_spe(swigCPtr, this, SWIGTYPE_p_std__ostream.getCPtr(output), SWIGTYPE_p_std__setT_int_t.getCPtr(sample_nums), SWIGTYPE_p_std__setT_int_t.getCPtr(det_nums)); + } + + public boolean write_cnf(SWIGTYPE_p_std__ostream output, SWIGTYPE_p_std__setT_int_t sample_nums, SWIGTYPE_p_std__setT_int_t det_nums) { + return SpecUtilsSwigJNI.SpecFile_write_cnf(swigCPtr, this, SWIGTYPE_p_std__ostream.getCPtr(output), SWIGTYPE_p_std__setT_int_t.getCPtr(sample_nums), SWIGTYPE_p_std__setT_int_t.getCPtr(det_nums)); + } + + public boolean write_tka(SWIGTYPE_p_std__ostream output, SWIGTYPE_p_std__setT_int_t sample_nums, SWIGTYPE_p_std__setT_int_t det_nums) { + return SpecUtilsSwigJNI.SpecFile_write_tka(swigCPtr, this, SWIGTYPE_p_std__ostream.getCPtr(output), SWIGTYPE_p_std__setT_int_t.getCPtr(sample_nums), SWIGTYPE_p_std__setT_int_t.getCPtr(det_nums)); + } + + public boolean write_d3_html(SWIGTYPE_p_std__ostream output, D3SpectrumChartOptions options, SWIGTYPE_p_std__setT_int_t sample_nums, StringVector det_names) { + return SpecUtilsSwigJNI.SpecFile_write_d3_html(swigCPtr, this, SWIGTYPE_p_std__ostream.getCPtr(output), D3SpectrumChartOptions.getCPtr(options), options, SWIGTYPE_p_std__setT_int_t.getCPtr(sample_nums), StringVector.getCPtr(det_names), det_names); + } + + public SWIGTYPE_p_std__shared_ptrT_rapidxml__xml_documentT_char_t_t create_2012_N42_xml() { + return new SWIGTYPE_p_std__shared_ptrT_rapidxml__xml_documentT_char_t_t(SpecUtilsSwigJNI.SpecFile_create_2012_N42_xml(swigCPtr, this), true); + } + + public boolean write_2012_N42(SWIGTYPE_p_std__ostream ostr) { + return SpecUtilsSwigJNI.SpecFile_write_2012_N42(swigCPtr, this, SWIGTYPE_p_std__ostream.getCPtr(ostr)); + } + + public SWIGTYPE_p_std__recursive_mutex mutex() { + return new SWIGTYPE_p_std__recursive_mutex(SpecUtilsSwigJNI.SpecFile_mutex(swigCPtr, this), false); + } + + public final static class DerivedVariantToKeep { + public final static SpecFile.DerivedVariantToKeep NonDerived = new SpecFile.DerivedVariantToKeep("NonDerived"); + public final static SpecFile.DerivedVariantToKeep Derived = new SpecFile.DerivedVariantToKeep("Derived"); + + public final int swigValue() { + return swigValue; + } + + public String toString() { + return swigName; + } + + public static DerivedVariantToKeep swigToEnum(int swigValue) { + if (swigValue < swigValues.length && swigValue >= 0 && swigValues[swigValue].swigValue == swigValue) + return swigValues[swigValue]; + for (int i = 0; i < swigValues.length; i++) + if (swigValues[i].swigValue == swigValue) + return swigValues[i]; + throw new IllegalArgumentException("No enum " + DerivedVariantToKeep.class + " with value " + swigValue); + } + + private DerivedVariantToKeep(String swigName) { + this.swigName = swigName; + this.swigValue = swigNext++; + } + + private DerivedVariantToKeep(String swigName, int swigValue) { + this.swigName = swigName; + this.swigValue = swigValue; + swigNext = swigValue+1; + } + + private DerivedVariantToKeep(String swigName, DerivedVariantToKeep swigEnum) { + this.swigName = swigName; + this.swigValue = swigEnum.swigValue; + swigNext = this.swigValue+1; + } + + private static DerivedVariantToKeep[] swigValues = { NonDerived, Derived }; + private static int swigNext = 0; + private final int swigValue; + private final String swigName; + } + + public final static class CleanupAfterLoadFlags { + public final static SpecFile.CleanupAfterLoadFlags RebinToCommonBinning = new SpecFile.CleanupAfterLoadFlags("RebinToCommonBinning", SpecUtilsSwigJNI.SpecFile_RebinToCommonBinning_get()); + public final static SpecFile.CleanupAfterLoadFlags DontChangeOrReorderSamples = new SpecFile.CleanupAfterLoadFlags("DontChangeOrReorderSamples", SpecUtilsSwigJNI.SpecFile_DontChangeOrReorderSamples_get()); + public final static SpecFile.CleanupAfterLoadFlags ReorderSamplesByTime = new SpecFile.CleanupAfterLoadFlags("ReorderSamplesByTime", SpecUtilsSwigJNI.SpecFile_ReorderSamplesByTime_get()); + public final static SpecFile.CleanupAfterLoadFlags StandardCleanup = new SpecFile.CleanupAfterLoadFlags("StandardCleanup", SpecUtilsSwigJNI.SpecFile_StandardCleanup_get()); + + public final int swigValue() { + return swigValue; + } + + public String toString() { + return swigName; + } + + public static CleanupAfterLoadFlags swigToEnum(int swigValue) { + if (swigValue < swigValues.length && swigValue >= 0 && swigValues[swigValue].swigValue == swigValue) + return swigValues[swigValue]; + for (int i = 0; i < swigValues.length; i++) + if (swigValues[i].swigValue == swigValue) + return swigValues[i]; + throw new IllegalArgumentException("No enum " + CleanupAfterLoadFlags.class + " with value " + swigValue); + } + + private CleanupAfterLoadFlags(String swigName) { + this.swigName = swigName; + this.swigValue = swigNext++; + } + + private CleanupAfterLoadFlags(String swigName, int swigValue) { + this.swigName = swigName; + this.swigValue = swigValue; + swigNext = swigValue+1; + } + + private CleanupAfterLoadFlags(String swigName, CleanupAfterLoadFlags swigEnum) { + this.swigName = swigName; + this.swigValue = swigEnum.swigValue; + swigNext = this.swigValue+1; + } + + private static CleanupAfterLoadFlags[] swigValues = { RebinToCommonBinning, DontChangeOrReorderSamples, ReorderSamplesByTime, StandardCleanup }; + private static int swigNext = 0; + private final int swigValue; + private final String swigName; + } + + public final static class SpcBinaryType { + public final static SpecFile.SpcBinaryType IntegerSpcType = new SpecFile.SpcBinaryType("IntegerSpcType"); + public final static SpecFile.SpcBinaryType FloatSpcType = new SpecFile.SpcBinaryType("FloatSpcType"); + + public final int swigValue() { + return swigValue; + } + + public String toString() { + return swigName; + } + + public static SpcBinaryType swigToEnum(int swigValue) { + if (swigValue < swigValues.length && swigValue >= 0 && swigValues[swigValue].swigValue == swigValue) + return swigValues[swigValue]; + for (int i = 0; i < swigValues.length; i++) + if (swigValues[i].swigValue == swigValue) + return swigValues[i]; + throw new IllegalArgumentException("No enum " + SpcBinaryType.class + " with value " + swigValue); + } + + private SpcBinaryType(String swigName) { + this.swigName = swigName; + this.swigValue = swigNext++; + } + + private SpcBinaryType(String swigName, int swigValue) { + this.swigName = swigName; + this.swigValue = swigValue; + swigNext = swigValue+1; + } + + private SpcBinaryType(String swigName, SpcBinaryType swigEnum) { + this.swigName = swigName; + this.swigValue = swigEnum.swigValue; + swigNext = this.swigValue+1; + } + + private static SpcBinaryType[] swigValues = { IntegerSpcType, FloatSpcType }; + private static int swigNext = 0; + private final int swigValue; + private final String swigName; + } + +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SpecUtilsJAVA_wrap.cxx b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SpecUtilsJAVA_wrap.cxx new file mode 100644 index 00000000..3f0e78be --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SpecUtilsJAVA_wrap.cxx @@ -0,0 +1,10357 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + + +#define SWIG_VERSION 0x040401 +#define SWIGJAVA + +/* ----------------------------------------------------------------------------- + * This section contains generic SWIG labels for method/variable + * declarations/attributes, and other compiler dependent labels. + * ----------------------------------------------------------------------------- */ + +/* template workaround for compilers that cannot correctly implement the C++ standard */ +#ifndef SWIGTEMPLATEDISAMBIGUATOR +# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) +# define SWIGTEMPLATEDISAMBIGUATOR template +# elif defined(__HP_aCC) +/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ +/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ +# define SWIGTEMPLATEDISAMBIGUATOR template +# else +# define SWIGTEMPLATEDISAMBIGUATOR +# endif +#endif + +/* inline attribute */ +#ifndef SWIGINLINE +# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) +# define SWIGINLINE inline +# else +# define SWIGINLINE +# endif +#endif + +/* attribute recognised by some compilers to avoid 'unused' warnings */ +#ifndef SWIGUNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +# elif defined(__ICC) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +#endif + +#ifndef SWIG_MSC_UNSUPPRESS_4505 +# if defined(_MSC_VER) +# pragma warning(disable : 4505) /* unreferenced local function has been removed */ +# endif +#endif + +#ifndef SWIGUNUSEDPARM +# ifdef __cplusplus +# define SWIGUNUSEDPARM(p) +# else +# define SWIGUNUSEDPARM(p) p SWIGUNUSED +# endif +#endif + +/* internal SWIG method */ +#ifndef SWIGINTERN +# define SWIGINTERN static SWIGUNUSED +#endif + +/* internal inline SWIG method */ +#ifndef SWIGINTERNINLINE +# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE +#endif + +/* exporting methods */ +#if defined(__GNUC__) +# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) +# ifndef GCC_HASCLASSVISIBILITY +# define GCC_HASCLASSVISIBILITY +# endif +# endif +#endif + +#ifndef SWIGEXPORT +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# if defined(STATIC_LINKED) +# define SWIGEXPORT +# else +# define SWIGEXPORT __declspec(dllexport) +# endif +# else +# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) +# define SWIGEXPORT __attribute__ ((visibility("default"))) +# else +# define SWIGEXPORT +# endif +# endif +#endif + +/* calling conventions for Windows */ +#ifndef SWIGSTDCALL +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# define SWIGSTDCALL __stdcall +# else +# define SWIGSTDCALL +# endif +#endif + +/* Deal with Microsoft's attempt at deprecating C standard runtime functions */ +#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) +# define _CRT_SECURE_NO_DEPRECATE +#endif + +/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ +#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) +# define _SCL_SECURE_NO_DEPRECATE +#endif + +/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */ +#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES) +# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0 +#endif + +/* Intel's compiler complains if a variable which was never initialised is + * cast to void, which is a common idiom which we use to indicate that we + * are aware a variable isn't used. So we just silence that warning. + * See: https://github.com/swig/swig/issues/192 for more discussion. + */ +#ifdef __INTEL_COMPILER +# pragma warning disable 592 +#endif + +#if defined(__cplusplus) && __cplusplus >=201103L +# define SWIG_NOEXCEPT noexcept +#else +# define SWIG_NOEXCEPT throw() +#endif + +/* ----------------------------------------------------------------------------- + * swigcompat.swg + * + * Macros to provide support compatibility with older C and C++ standards. + * + * Note that SWIG expects __cplusplus to be defined to the appropriate C++ standard. + * MSVC users are urged to check and examine the /Zc:__cplusplus compiler option. + * See https://learn.microsoft.com/en-us/cpp/build/reference/zc-cplusplus. + * ----------------------------------------------------------------------------- */ + +/* C99 and C++11 should provide snprintf, but define SWIG_NO_SNPRINTF + * if you're missing it. + */ +#if ((defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) || \ + (defined __cplusplus && __cplusplus >= 201103L) || \ + defined SWIG_HAVE_SNPRINTF) && \ + !defined SWIG_NO_SNPRINTF +# define SWIG_snprintf(O,S,F,A) snprintf(O,S,F,A) +# define SWIG_snprintf2(O,S,F,A,B) snprintf(O,S,F,A,B) +#else +/* Fallback versions ignore the buffer size, but most of our uses either have a + * fixed maximum possible size or dynamically allocate a buffer that's large + * enough. + */ +# define SWIG_snprintf(O,S,F,A) sprintf(O,F,A) +# define SWIG_snprintf2(O,S,F,A,B) sprintf(O,F,A,B) +#endif + + +#include +#include +#include + + +/* Support for throwing Java exceptions */ +typedef enum { + SWIG_JavaOutOfMemoryError = 1, + SWIG_JavaIOException, + SWIG_JavaRuntimeException, + SWIG_JavaIndexOutOfBoundsException, + SWIG_JavaArithmeticException, + SWIG_JavaIllegalArgumentException, + SWIG_JavaNullPointerException, + SWIG_JavaDirectorPureVirtual, + SWIG_JavaUnknownError, + SWIG_JavaIllegalStateException, +} SWIG_JavaExceptionCodes; + +typedef struct { + SWIG_JavaExceptionCodes code; + const char *java_exception; +} SWIG_JavaExceptions_t; + + +static void SWIGUNUSED SWIG_JavaThrowException(JNIEnv *jenv, SWIG_JavaExceptionCodes code, const char *msg) { + jclass excep; + static const SWIG_JavaExceptions_t java_exceptions[] = { + { SWIG_JavaOutOfMemoryError, "java/lang/OutOfMemoryError" }, + { SWIG_JavaIOException, "java/io/IOException" }, + { SWIG_JavaRuntimeException, "java/lang/RuntimeException" }, + { SWIG_JavaIndexOutOfBoundsException, "java/lang/IndexOutOfBoundsException" }, + { SWIG_JavaArithmeticException, "java/lang/ArithmeticException" }, + { SWIG_JavaIllegalArgumentException, "java/lang/IllegalArgumentException" }, + { SWIG_JavaNullPointerException, "java/lang/NullPointerException" }, + { SWIG_JavaDirectorPureVirtual, "java/lang/RuntimeException" }, + { SWIG_JavaUnknownError, "java/lang/UnknownError" }, + { SWIG_JavaIllegalStateException, "java/lang/IllegalStateException" }, + { (SWIG_JavaExceptionCodes)0, "java/lang/UnknownError" } + }; + const SWIG_JavaExceptions_t *except_ptr = java_exceptions; + + while (except_ptr->code != code && except_ptr->code) + except_ptr++; + + jenv->ExceptionClear(); + excep = jenv->FindClass(except_ptr->java_exception); + if (excep) + jenv->ThrowNew(excep, msg); +} + + +/* Contract support */ + +#define SWIG_contract_assert(nullreturn, expr, msg) do { if (!(expr)) {SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, msg); return nullreturn; } } while (0) + + +#ifdef __cplusplus +#include +/* SwigValueWrapper is described in swig.swg */ +template class SwigValueWrapper { + struct SwigSmartPointer { + T *ptr; + SwigSmartPointer(T *p) : ptr(p) { } + ~SwigSmartPointer() { delete ptr; } + SwigSmartPointer& operator=(SwigSmartPointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; } + void reset(T *p) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = p; } + } pointer; + SwigValueWrapper& operator=(const SwigValueWrapper& rhs); + SwigValueWrapper(const SwigValueWrapper& rhs); +public: + SwigValueWrapper() : pointer(0) { } + SwigValueWrapper& operator=(const T& t) { SwigSmartPointer tmp(new T(t)); pointer = tmp; return *this; } +#if __cplusplus >=201103L + SwigValueWrapper& operator=(T&& t) { SwigSmartPointer tmp(new T(std::move(t))); pointer = tmp; return *this; } + operator T&&() const { return std::move(*pointer.ptr); } +#else + operator T&() const { return *pointer.ptr; } +#endif + T *operator&() const { return pointer.ptr; } + static void reset(SwigValueWrapper& t, T *p) { t.pointer.reset(p); } +}; + +/* + * SwigValueInit() is a generic initialisation solution as the following approach: + * + * T c_result = T(); + * + * doesn't compile for all types for example: + * + * unsigned int c_result = unsigned int(); + */ +template T SwigValueInit() { + return T(); +} + +#if __cplusplus >=201103L +# define SWIG_STD_MOVE(OBJ) std::move(OBJ) +#else +# define SWIG_STD_MOVE(OBJ) OBJ +#endif + +#endif + +#if defined(__cplusplus) && (__cplusplus >=201103L) +# define SWIG_OVERRIDE override +#else +# define SWIG_OVERRIDE +#endif + + + +#include + + +#include +#include + + +#include +#include + + +/* Check for overflow converting to Java int (always signed 32-bit) from (unsigned variable-bit) size_t */ +SWIGINTERN jint SWIG_JavaIntFromSize_t(size_t size) { + static const jint JINT_MAX = 0x7FFFFFFF; + return (size > (size_t)JINT_MAX) ? -1 : (jint)size; +} + + +SWIGINTERN jint SWIG_VectorSize(size_t size) { + jint sz = SWIG_JavaIntFromSize_t(size); + if (sz == -1) + throw std::out_of_range("vector size is too large to fit into a Java int"); + return sz; +} + +SWIGINTERN std::vector< std::string > *new_std_vector_Sl_std_string_Sg___SWIG_2(jint count,std::string const &value){ + if (count < 0) + throw std::out_of_range("vector count must be positive"); + return new std::vector< std::string >(static_cast::size_type>(count), value); + } +SWIGINTERN jint std_vector_Sl_std_string_Sg__doCapacity(std::vector< std::string > *self){ + return SWIG_VectorSize(self->capacity()); + } +SWIGINTERN void std_vector_Sl_std_string_Sg__doReserve(std::vector< std::string > *self,jint n){ + if (n < 0) + throw std::out_of_range("vector reserve size must be positive"); + self->reserve(n); + } +SWIGINTERN jint std_vector_Sl_std_string_Sg__doSize(std::vector< std::string > const *self){ + return SWIG_VectorSize(self->size()); + } +SWIGINTERN void std_vector_Sl_std_string_Sg__doAdd__SWIG_0(std::vector< std::string > *self,std::vector< std::string >::value_type const &x){ + self->push_back(x); + } +SWIGINTERN void std_vector_Sl_std_string_Sg__doAdd__SWIG_1(std::vector< std::string > *self,jint index,std::vector< std::string >::value_type const &x){ + jint size = static_cast(self->size()); + if (0 <= index && index <= size) { + self->insert(self->begin() + index, x); + } else { + throw std::out_of_range("vector index out of range"); + } + } +SWIGINTERN std::vector< std::string >::value_type std_vector_Sl_std_string_Sg__doRemove(std::vector< std::string > *self,jint index){ + jint size = static_cast(self->size()); + if (0 <= index && index < size) { + std::string const old_value = (*self)[index]; + self->erase(self->begin() + index); + return old_value; + } else { + throw std::out_of_range("vector index out of range"); + } + } +SWIGINTERN std::vector< std::string >::value_type const &std_vector_Sl_std_string_Sg__doGet(std::vector< std::string > *self,jint index){ + jint size = static_cast(self->size()); + if (index >= 0 && index < size) + return (*self)[index]; + else + throw std::out_of_range("vector index out of range"); + } +SWIGINTERN std::vector< std::string >::value_type std_vector_Sl_std_string_Sg__doSet(std::vector< std::string > *self,jint index,std::vector< std::string >::value_type const &val){ + jint size = static_cast(self->size()); + if (index >= 0 && index < size) { + std::string const old_value = (*self)[index]; + (*self)[index] = val; + return old_value; + } + else + throw std::out_of_range("vector index out of range"); + } +SWIGINTERN void std_vector_Sl_std_string_Sg__doRemoveRange(std::vector< std::string > *self,jint fromIndex,jint toIndex){ + jint size = static_cast(self->size()); + if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) { + self->erase(self->begin() + fromIndex, self->begin() + toIndex); + } else { + throw std::out_of_range("vector index out of range"); + } + } +SWIGINTERN std::vector< int > *new_std_vector_Sl_int_Sg___SWIG_2(jint count,int const &value){ + if (count < 0) + throw std::out_of_range("vector count must be positive"); + return new std::vector< int >(static_cast::size_type>(count), value); + } +SWIGINTERN jint std_vector_Sl_int_Sg__doCapacity(std::vector< int > *self){ + return SWIG_VectorSize(self->capacity()); + } +SWIGINTERN void std_vector_Sl_int_Sg__doReserve(std::vector< int > *self,jint n){ + if (n < 0) + throw std::out_of_range("vector reserve size must be positive"); + self->reserve(n); + } +SWIGINTERN jint std_vector_Sl_int_Sg__doSize(std::vector< int > const *self){ + return SWIG_VectorSize(self->size()); + } +SWIGINTERN void std_vector_Sl_int_Sg__doAdd__SWIG_0(std::vector< int > *self,std::vector< int >::value_type const &x){ + self->push_back(x); + } +SWIGINTERN void std_vector_Sl_int_Sg__doAdd__SWIG_1(std::vector< int > *self,jint index,std::vector< int >::value_type const &x){ + jint size = static_cast(self->size()); + if (0 <= index && index <= size) { + self->insert(self->begin() + index, x); + } else { + throw std::out_of_range("vector index out of range"); + } + } +SWIGINTERN std::vector< int >::value_type std_vector_Sl_int_Sg__doRemove(std::vector< int > *self,jint index){ + jint size = static_cast(self->size()); + if (0 <= index && index < size) { + int const old_value = (*self)[index]; + self->erase(self->begin() + index); + return old_value; + } else { + throw std::out_of_range("vector index out of range"); + } + } +SWIGINTERN std::vector< int >::value_type const &std_vector_Sl_int_Sg__doGet(std::vector< int > *self,jint index){ + jint size = static_cast(self->size()); + if (index >= 0 && index < size) + return (*self)[index]; + else + throw std::out_of_range("vector index out of range"); + } +SWIGINTERN std::vector< int >::value_type std_vector_Sl_int_Sg__doSet(std::vector< int > *self,jint index,std::vector< int >::value_type const &val){ + jint size = static_cast(self->size()); + if (index >= 0 && index < size) { + int const old_value = (*self)[index]; + (*self)[index] = val; + return old_value; + } + else + throw std::out_of_range("vector index out of range"); + } +SWIGINTERN void std_vector_Sl_int_Sg__doRemoveRange(std::vector< int > *self,jint fromIndex,jint toIndex){ + jint size = static_cast(self->size()); + if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) { + self->erase(self->begin() + fromIndex, self->begin() + toIndex); + } else { + throw std::out_of_range("vector index out of range"); + } + } + +struct SWIG_null_deleter { + void operator() (void const *) const { + } +}; +#define SWIG_NO_NULL_DELETER_0 , SWIG_null_deleter() +#define SWIG_NO_NULL_DELETER_1 +#define SWIG_NO_NULL_DELETER_SWIG_POINTER_NEW +#define SWIG_NO_NULL_DELETER_SWIG_POINTER_OWN + +SWIGINTERN std::vector< float > *new_std_vector_Sl_float_Sg___SWIG_2(jint count,float const &value){ + if (count < 0) + throw std::out_of_range("vector count must be positive"); + return new std::vector< float >(static_cast::size_type>(count), value); + } +SWIGINTERN jint std_vector_Sl_float_Sg__doCapacity(std::vector< float > *self){ + return SWIG_VectorSize(self->capacity()); + } +SWIGINTERN void std_vector_Sl_float_Sg__doReserve(std::vector< float > *self,jint n){ + if (n < 0) + throw std::out_of_range("vector reserve size must be positive"); + self->reserve(n); + } +SWIGINTERN jint std_vector_Sl_float_Sg__doSize(std::vector< float > const *self){ + return SWIG_VectorSize(self->size()); + } +SWIGINTERN void std_vector_Sl_float_Sg__doAdd__SWIG_0(std::vector< float > *self,std::vector< float >::value_type const &x){ + self->push_back(x); + } +SWIGINTERN void std_vector_Sl_float_Sg__doAdd__SWIG_1(std::vector< float > *self,jint index,std::vector< float >::value_type const &x){ + jint size = static_cast(self->size()); + if (0 <= index && index <= size) { + self->insert(self->begin() + index, x); + } else { + throw std::out_of_range("vector index out of range"); + } + } +SWIGINTERN std::vector< float >::value_type std_vector_Sl_float_Sg__doRemove(std::vector< float > *self,jint index){ + jint size = static_cast(self->size()); + if (0 <= index && index < size) { + float const old_value = (*self)[index]; + self->erase(self->begin() + index); + return old_value; + } else { + throw std::out_of_range("vector index out of range"); + } + } +SWIGINTERN std::vector< float >::value_type const &std_vector_Sl_float_Sg__doGet(std::vector< float > *self,jint index){ + jint size = static_cast(self->size()); + if (index >= 0 && index < size) + return (*self)[index]; + else + throw std::out_of_range("vector index out of range"); + } +SWIGINTERN std::vector< float >::value_type std_vector_Sl_float_Sg__doSet(std::vector< float > *self,jint index,std::vector< float >::value_type const &val){ + jint size = static_cast(self->size()); + if (index >= 0 && index < size) { + float const old_value = (*self)[index]; + (*self)[index] = val; + return old_value; + } + else + throw std::out_of_range("vector index out of range"); + } +SWIGINTERN void std_vector_Sl_float_Sg__doRemoveRange(std::vector< float > *self,jint fromIndex,jint toIndex){ + jint size = static_cast(self->size()); + if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) { + self->erase(self->begin() + fromIndex, self->begin() + toIndex); + } else { + throw std::out_of_range("vector index out of range"); + } + } + +#include +#include +#include +#include +using namespace std; + + +std::ostream* openFile(const char* filename) { + ofstream *filePtr = new ofstream(filename); + return(filePtr); +} +void closeFile(std::ostream *stream) { + stream->flush(); + delete(stream); +} + + +#include +#include + + +#include +#include "SpecUtils/SpecFile.h" + + +#include "SpecUtils/EnergyCalibration.h" + + +#include + + +#include "D3SpectrumExportResources.h" +#include "SpecUtils/D3SpectrumExport.h" + + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_new_1StringVector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + std::vector< std::string > *result = 0 ; + + (void)jenv; + (void)jcls; + result = (std::vector< std::string > *)new std::vector< std::string >(); + *(std::vector< std::string > **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_new_1StringVector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + std::vector< std::string > *arg1 = 0 ; + std::vector< std::string > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< std::string > **)&jarg1; + if (!arg1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::string > const & is null"); + return 0; + } + result = (std::vector< std::string > *)new std::vector< std::string >((std::vector< std::string > const &)*arg1); + *(std::vector< std::string > **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_StringVector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + std::vector< std::string > *arg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< std::string > **)&jarg1; + result = (bool)((std::vector< std::string > const *)arg1)->empty(); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_StringVector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + std::vector< std::string > *arg1 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< std::string > **)&jarg1; + (arg1)->clear(); +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_new_1StringVector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jstring jarg2) { + jlong jresult = 0 ; + jint arg1 ; + std::string *arg2 = 0 ; + std::vector< std::string > *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return 0; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + try { + result = (std::vector< std::string > *)new_std_vector_Sl_std_string_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(std::string const &)*arg2); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return 0; + } + *(std::vector< std::string > **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_StringVector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + std::vector< std::string > *arg1 = 0 ; + jint result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< std::string > **)&jarg1; + try { + result = std_vector_Sl_std_string_Sg__doCapacity(arg1); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return 0; + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_StringVector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + std::vector< std::string > *arg1 = 0 ; + jint arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< std::string > **)&jarg1; + arg2 = jarg2; + try { + std_vector_Sl_std_string_Sg__doReserve(arg1,SWIG_STD_MOVE(arg2)); + } catch(std::length_error &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return ; + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return ; + } +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_StringVector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + std::vector< std::string > *arg1 = 0 ; + jint result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< std::string > **)&jarg1; + try { + result = std_vector_Sl_std_string_Sg__doSize((std::vector< std::string > const *)arg1); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return 0; + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_StringVector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + std::vector< std::string > *arg1 = 0 ; + std::vector< std::string >::value_type *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< std::string > **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::vector< std::string >::value_type arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + std_vector_Sl_std_string_Sg__doAdd__SWIG_0(arg1,(std::string const &)*arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_StringVector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jstring jarg3) { + std::vector< std::string > *arg1 = 0 ; + jint arg2 ; + std::vector< std::string >::value_type *arg3 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< std::string > **)&jarg1; + arg2 = jarg2; + if(!jarg3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); + if (!arg3_pstr) return ; + std::vector< std::string >::value_type arg3_str(arg3_pstr); + arg3 = &arg3_str; + jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); + try { + std_vector_Sl_std_string_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(std::string const &)*arg3); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return ; + } +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_StringVector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jstring jresult = 0 ; + std::vector< std::string > *arg1 = 0 ; + jint arg2 ; + std::vector< std::string >::value_type result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< std::string > **)&jarg1; + arg2 = jarg2; + try { + result = std_vector_Sl_std_string_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2)); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return 0; + } + jresult = jenv->NewStringUTF((&result)->c_str()); + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_StringVector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jstring jresult = 0 ; + std::vector< std::string > *arg1 = 0 ; + jint arg2 ; + std::vector< std::string >::value_type *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< std::string > **)&jarg1; + arg2 = jarg2; + try { + result = (std::vector< std::string >::value_type *) &std_vector_Sl_std_string_Sg__doGet(arg1,SWIG_STD_MOVE(arg2)); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return 0; + } + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_StringVector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jstring jarg3) { + jstring jresult = 0 ; + std::vector< std::string > *arg1 = 0 ; + jint arg2 ; + std::vector< std::string >::value_type *arg3 = 0 ; + std::vector< std::string >::value_type result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< std::string > **)&jarg1; + arg2 = jarg2; + if(!jarg3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); + if (!arg3_pstr) return 0; + std::vector< std::string >::value_type arg3_str(arg3_pstr); + arg3 = &arg3_str; + jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); + try { + result = std_vector_Sl_std_string_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(std::string const &)*arg3); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return 0; + } + jresult = jenv->NewStringUTF((&result)->c_str()); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_StringVector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) { + std::vector< std::string > *arg1 = 0 ; + jint arg2 ; + jint arg3 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< std::string > **)&jarg1; + arg2 = jarg2; + arg3 = jarg3; + try { + std_vector_Sl_std_string_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return ; + } +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_delete_1StringVector(JNIEnv *jenv, jclass jcls, jlong jarg1) { + std::vector< std::string > *arg1 = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(std::vector< std::string > **)&jarg1; + delete arg1; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_new_1IntVector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + std::vector< int > *result = 0 ; + + (void)jenv; + (void)jcls; + result = (std::vector< int > *)new std::vector< int >(); + *(std::vector< int > **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_new_1IntVector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + std::vector< int > *arg1 = 0 ; + std::vector< int > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< int > **)&jarg1; + if (!arg1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int > const & is null"); + return 0; + } + result = (std::vector< int > *)new std::vector< int >((std::vector< int > const &)*arg1); + *(std::vector< int > **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_IntVector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + std::vector< int > *arg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< int > **)&jarg1; + result = (bool)((std::vector< int > const *)arg1)->empty(); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_IntVector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + std::vector< int > *arg1 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< int > **)&jarg1; + (arg1)->clear(); +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_new_1IntVector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2) { + jlong jresult = 0 ; + jint arg1 ; + int *arg2 = 0 ; + int temp2 ; + std::vector< int > *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = jarg1; + temp2 = (int)jarg2; + arg2 = &temp2; + try { + result = (std::vector< int > *)new_std_vector_Sl_int_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(int const &)*arg2); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return 0; + } + *(std::vector< int > **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_IntVector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + std::vector< int > *arg1 = 0 ; + jint result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< int > **)&jarg1; + try { + result = std_vector_Sl_int_Sg__doCapacity(arg1); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return 0; + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_IntVector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + std::vector< int > *arg1 = 0 ; + jint arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< int > **)&jarg1; + arg2 = jarg2; + try { + std_vector_Sl_int_Sg__doReserve(arg1,SWIG_STD_MOVE(arg2)); + } catch(std::length_error &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return ; + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return ; + } +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_IntVector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + std::vector< int > *arg1 = 0 ; + jint result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< int > **)&jarg1; + try { + result = std_vector_Sl_int_Sg__doSize((std::vector< int > const *)arg1); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return 0; + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_IntVector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + std::vector< int > *arg1 = 0 ; + std::vector< int >::value_type *arg2 = 0 ; + std::vector< int >::value_type temp2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< int > **)&jarg1; + temp2 = (std::vector< int >::value_type)jarg2; + arg2 = &temp2; + std_vector_Sl_int_Sg__doAdd__SWIG_0(arg1,(int const &)*arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_IntVector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) { + std::vector< int > *arg1 = 0 ; + jint arg2 ; + std::vector< int >::value_type *arg3 = 0 ; + std::vector< int >::value_type temp3 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< int > **)&jarg1; + arg2 = jarg2; + temp3 = (std::vector< int >::value_type)jarg3; + arg3 = &temp3; + try { + std_vector_Sl_int_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(int const &)*arg3); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return ; + } +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_IntVector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jint jresult = 0 ; + std::vector< int > *arg1 = 0 ; + jint arg2 ; + std::vector< int >::value_type result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< int > **)&jarg1; + arg2 = jarg2; + try { + result = (std::vector< int >::value_type)std_vector_Sl_int_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2)); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return 0; + } + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_IntVector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jint jresult = 0 ; + std::vector< int > *arg1 = 0 ; + jint arg2 ; + std::vector< int >::value_type *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< int > **)&jarg1; + arg2 = jarg2; + try { + result = (std::vector< int >::value_type *) &std_vector_Sl_int_Sg__doGet(arg1,SWIG_STD_MOVE(arg2)); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return 0; + } + jresult = (jint)*result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_IntVector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) { + jint jresult = 0 ; + std::vector< int > *arg1 = 0 ; + jint arg2 ; + std::vector< int >::value_type *arg3 = 0 ; + std::vector< int >::value_type temp3 ; + std::vector< int >::value_type result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< int > **)&jarg1; + arg2 = jarg2; + temp3 = (std::vector< int >::value_type)jarg3; + arg3 = &temp3; + try { + result = (std::vector< int >::value_type)std_vector_Sl_int_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(int const &)*arg3); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return 0; + } + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_IntVector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) { + std::vector< int > *arg1 = 0 ; + jint arg2 ; + jint arg3 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(std::vector< int > **)&jarg1; + arg2 = jarg2; + arg3 = jarg3; + try { + std_vector_Sl_int_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return ; + } +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_delete_1IntVector(JNIEnv *jenv, jclass jcls, jlong jarg1) { + std::vector< int > *arg1 = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(std::vector< int > **)&jarg1; + delete arg1; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_new_1FloatVector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + std::vector< float > *result = 0 ; + + (void)jenv; + (void)jcls; + result = (std::vector< float > *)new std::vector< float >(); + + *(std::shared_ptr< std::vector > **)&jresult = result ? new std::shared_ptr< std::vector >(result SWIG_NO_NULL_DELETER_1) : 0; + + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_new_1FloatVector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + std::vector< float > *arg1 = 0 ; + std::vector< float > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + arg1 = (std::vector< float > *)((*(std::shared_ptr< const std::vector > **)&jarg1) ? (*(std::shared_ptr< const std::vector > **)&jarg1)->get() : 0); + if (!arg1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< float > const & reference is null"); + return 0; + } + result = (std::vector< float > *)new std::vector< float >((std::vector< float > const &)*arg1); + + *(std::shared_ptr< std::vector > **)&jresult = result ? new std::shared_ptr< std::vector >(result SWIG_NO_NULL_DELETER_1) : 0; + + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_FloatVector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + std::vector< float > *arg1 = 0 ; + std::shared_ptr< std::vector< float > const > *smartarg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const std::vector > **)&jarg1; + arg1 = (std::vector *)(smartarg1 ? smartarg1->get() : 0); + result = (bool)((std::vector< float > const *)arg1)->empty(); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_FloatVector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + std::vector< float > *arg1 = 0 ; + std::shared_ptr< std::vector< float > > *smartarg1 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< std::vector > **)&jarg1; + arg1 = (std::vector *)(smartarg1 ? smartarg1->get() : 0); + (arg1)->clear(); +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_new_1FloatVector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jfloat jarg2) { + jlong jresult = 0 ; + jint arg1 ; + float *arg2 = 0 ; + float temp2 ; + std::vector< float > *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = jarg1; + temp2 = (float)jarg2; + arg2 = &temp2; + try { + result = (std::vector< float > *)new_std_vector_Sl_float_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(float const &)*arg2); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return 0; + } + + *(std::shared_ptr< std::vector > **)&jresult = result ? new std::shared_ptr< std::vector >(result SWIG_NO_NULL_DELETER_1) : 0; + + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_FloatVector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + std::vector< float > *arg1 = 0 ; + std::shared_ptr< std::vector< float > > *smartarg1 = 0 ; + jint result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< std::vector > **)&jarg1; + arg1 = (std::vector *)(smartarg1 ? smartarg1->get() : 0); + try { + result = std_vector_Sl_float_Sg__doCapacity(arg1); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return 0; + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_FloatVector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + std::vector< float > *arg1 = 0 ; + jint arg2 ; + std::shared_ptr< std::vector< float > > *smartarg1 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< std::vector > **)&jarg1; + arg1 = (std::vector *)(smartarg1 ? smartarg1->get() : 0); + arg2 = jarg2; + try { + std_vector_Sl_float_Sg__doReserve(arg1,SWIG_STD_MOVE(arg2)); + } catch(std::length_error &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return ; + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return ; + } +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_FloatVector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + std::vector< float > *arg1 = 0 ; + std::shared_ptr< std::vector< float > const > *smartarg1 = 0 ; + jint result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const std::vector > **)&jarg1; + arg1 = (std::vector *)(smartarg1 ? smartarg1->get() : 0); + try { + result = std_vector_Sl_float_Sg__doSize((std::vector< float > const *)arg1); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return 0; + } + jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_FloatVector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { + std::vector< float > *arg1 = 0 ; + std::vector< float >::value_type *arg2 = 0 ; + std::shared_ptr< std::vector< float > > *smartarg1 = 0 ; + std::vector< float >::value_type temp2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< std::vector > **)&jarg1; + arg1 = (std::vector *)(smartarg1 ? smartarg1->get() : 0); + temp2 = (std::vector< float >::value_type)jarg2; + arg2 = &temp2; + std_vector_Sl_float_Sg__doAdd__SWIG_0(arg1,(float const &)*arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_FloatVector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jfloat jarg3) { + std::vector< float > *arg1 = 0 ; + jint arg2 ; + std::vector< float >::value_type *arg3 = 0 ; + std::shared_ptr< std::vector< float > > *smartarg1 = 0 ; + std::vector< float >::value_type temp3 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< std::vector > **)&jarg1; + arg1 = (std::vector *)(smartarg1 ? smartarg1->get() : 0); + arg2 = jarg2; + temp3 = (std::vector< float >::value_type)jarg3; + arg3 = &temp3; + try { + std_vector_Sl_float_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(float const &)*arg3); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return ; + } +} + + +SWIGEXPORT jfloat JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_FloatVector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jfloat jresult = 0 ; + std::vector< float > *arg1 = 0 ; + jint arg2 ; + std::shared_ptr< std::vector< float > > *smartarg1 = 0 ; + std::vector< float >::value_type result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< std::vector > **)&jarg1; + arg1 = (std::vector *)(smartarg1 ? smartarg1->get() : 0); + arg2 = jarg2; + try { + result = (std::vector< float >::value_type)std_vector_Sl_float_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2)); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return 0; + } + jresult = (jfloat)result; + return jresult; +} + + +SWIGEXPORT jfloat JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_FloatVector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jfloat jresult = 0 ; + std::vector< float > *arg1 = 0 ; + jint arg2 ; + std::shared_ptr< std::vector< float > > *smartarg1 = 0 ; + std::vector< float >::value_type *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< std::vector > **)&jarg1; + arg1 = (std::vector *)(smartarg1 ? smartarg1->get() : 0); + arg2 = jarg2; + try { + result = (std::vector< float >::value_type *) &std_vector_Sl_float_Sg__doGet(arg1,SWIG_STD_MOVE(arg2)); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return 0; + } + jresult = (jfloat)*result; + return jresult; +} + + +SWIGEXPORT jfloat JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_FloatVector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jfloat jarg3) { + jfloat jresult = 0 ; + std::vector< float > *arg1 = 0 ; + jint arg2 ; + std::vector< float >::value_type *arg3 = 0 ; + std::shared_ptr< std::vector< float > > *smartarg1 = 0 ; + std::vector< float >::value_type temp3 ; + std::vector< float >::value_type result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< std::vector > **)&jarg1; + arg1 = (std::vector *)(smartarg1 ? smartarg1->get() : 0); + arg2 = jarg2; + temp3 = (std::vector< float >::value_type)jarg3; + arg3 = &temp3; + try { + result = (std::vector< float >::value_type)std_vector_Sl_float_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(float const &)*arg3); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return 0; + } + jresult = (jfloat)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_FloatVector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) { + std::vector< float > *arg1 = 0 ; + jint arg2 ; + jint arg3 ; + std::shared_ptr< std::vector< float > > *smartarg1 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< std::vector > **)&jarg1; + arg1 = (std::vector *)(smartarg1 ? smartarg1->get() : 0); + arg2 = jarg2; + arg3 = jarg3; + try { + std_vector_Sl_float_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); + } catch(std::out_of_range &_e) { + SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what()); + return ; + } +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_delete_1FloatVector(JNIEnv *jenv, jclass jcls, jlong jarg1) { + std::vector< float > *arg1 = 0 ; + std::shared_ptr< std::vector< float > > *smartarg1 = 0 ; + + (void)jenv; + (void)jcls; + + smartarg1 = *(std::shared_ptr< std::vector > **)&jarg1; + arg1 = (std::vector *)(smartarg1 ? smartarg1->get() : 0); + (void)arg1; delete smartarg1; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_openFile(JNIEnv *jenv, jclass jcls, jstring jarg1) { + jlong jresult = 0 ; + char *arg1 = 0 ; + std::ostream *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = 0; + if (jarg1) { + arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0); + if (!arg1) return 0; + } + result = (std::ostream *)openFile((char const *)arg1); + *(std::ostream **)&jresult = result; + if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_closeFile(JNIEnv *jenv, jclass jcls, jlong jarg1) { + std::ostream *arg1 = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(std::ostream **)&jarg1; + closeFile(arg1); +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_PERFORM_1DEVELOPER_1CHECKS_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + int result; + + (void)jenv; + (void)jcls; + result = (int)(0); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecUtils_1ENABLE_1D3_1CHART_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + int result; + + (void)jenv; + (void)jcls; + result = (int)(1); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecUtils_1ENABLE_1URI_1SPECTRA_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + int result; + + (void)jenv; + (void)jcls; + result = (int)(0); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecUtils_1USE_1WT_1THREADPOOL_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + int result; + + (void)jenv; + (void)jcls; + result = (int)(0); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecUtils_1USING_1NO_1THREADING_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + int result; + + (void)jenv; + (void)jcls; + result = (int)(0); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecUtils_1D3_1SUPPORT_1FILE_1STATIC_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + int result; + + (void)jenv; + (void)jcls; + result = (int)(1); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecUtils_1INJA_1TEMPLATES_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + int result; + + (void)jenv; + (void)jcls; + result = (int)(0); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecUtils_1BUILD_1FUZZING_1TESTS_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + int result; + + (void)jenv; + (void)jcls; + result = (int)(0); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecUtils_1PYTHON_1BINDINGS_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + int result; + + (void)jenv; + (void)jcls; + result = (int)(0); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecUtils_1JAVA_1SWIG_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + int result; + + (void)jenv; + (void)jcls; + result = (int)(1); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecUtils_1USE_1SIMD_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + int result; + + (void)jenv; + (void)jcls; + result = (int)(0); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecUtils_1ENABLE_1EQUALITY_1CHECKS_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + int result; + + (void)jenv; + (void)jcls; + result = (int)(0); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecUtils_1USE_1FROM_1CHARS_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + int result; + + (void)jenv; + (void)jcls; + result = (int)(0); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_descriptionText_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jint jarg1) { + jstring jresult = 0 ; + SpecUtils::SpectrumType arg1 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = (SpecUtils::SpectrumType)jarg1; + result = (char *)SpecUtils::descriptionText(arg1); + if (result) jresult = jenv->NewStringUTF((const char *)result); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_spectrumTypeFromDescription(JNIEnv *jenv, jclass jcls, jstring jarg1) { + jint jresult = 0 ; + char *arg1 = 0 ; + SpecUtils::SpectrumType result; + + (void)jenv; + (void)jcls; + arg1 = 0; + if (jarg1) { + arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0); + if (!arg1) return 0; + } + result = (SpecUtils::SpectrumType)SpecUtils::spectrumTypeFromDescription((char const *)arg1); + jresult = (jint)result; + if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1); + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_suggestedNameEnding(JNIEnv *jenv, jclass jcls, jint jarg1) { + jstring jresult = 0 ; + SpecUtils::SaveSpectrumAsType arg1 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = (SpecUtils::SaveSpectrumAsType)jarg1; + result = (char *)SpecUtils::suggestedNameEnding(arg1); + if (result) jresult = jenv->NewStringUTF((const char *)result); + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_descriptionText_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jint jarg1) { + jstring jresult = 0 ; + SpecUtils::SaveSpectrumAsType arg1 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = (SpecUtils::SaveSpectrumAsType)jarg1; + result = (char *)SpecUtils::descriptionText(arg1); + if (result) jresult = jenv->NewStringUTF((const char *)result); + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_is_1candidate_1n42_1file_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1) { + jboolean jresult = 0 ; + char *arg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + arg1 = 0; + if (jarg1) { + arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0); + if (!arg1) return 0; + } + result = (bool)SpecUtils::is_candidate_n42_file((char const *)arg1); + jresult = (jboolean)result; + if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1); + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_is_1candidate_1n42_1file_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2) { + jboolean jresult = 0 ; + char *arg1 = (char *)0 ; + char *arg2 = (char *)0 ; + bool result; + + (void)jenv; + (void)jcls; + arg1 = 0; + if (jarg1) { + arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0); + if (!arg1) return 0; + } + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + result = (bool)SpecUtils::is_candidate_n42_file((char const *)arg1,(char const *)arg2); + jresult = (jboolean)result; + if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1); + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_convert_1n42_1utf16_1xml_1to_1utf8(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2) { + jstring jresult = 0 ; + char *arg1 = 0 ; + char *arg2 = (char *)0 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = 0; + if (jarg1) { + arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0); + if (!arg1) return 0; + } + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + result = (char *)SpecUtils::convert_n42_utf16_xml_to_utf8(arg1,arg2); + if (result) jresult = jenv->NewStringUTF((const char *)result); + if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1); + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_add_1analysis_1results_1to_12012_1N42(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3) { + SpecUtils::DetectorAnalysis *arg1 = 0 ; + ::rapidxml::xml_node< char > *arg2 = 0 ; + std::mutex *arg3 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysis **)&jarg1; + if (!arg1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "SpecUtils::DetectorAnalysis const & is null"); + return ; + } + arg2 = *(::rapidxml::xml_node< char > **)&jarg2; + arg3 = *(std::mutex **)&jarg3; + if (!arg3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::mutex & is null"); + return ; + } + SpecUtils::add_analysis_results_to_2012_N42((SpecUtils::DetectorAnalysis const &)*arg1,arg2,*arg3); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_set_1analysis_1info_1from_1n42(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jobject jarg2_) { + rapidxml::xml_node< char > *arg1 = 0 ; + SpecUtils::DetectorAnalysis *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg2_; + arg1 = *(rapidxml::xml_node< char > **)&jarg1; + arg2 = *(SpecUtils::DetectorAnalysis **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "SpecUtils::DetectorAnalysis & is null"); + return ; + } + SpecUtils::set_analysis_info_from_n42((rapidxml::xml_node< char > const *)arg1,*arg2); +} + + +SWIGEXPORT jdouble JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_gamma_1integral(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jfloat jarg3) { + jdouble jresult = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *arg1 = 0 ; + float arg2 ; + float arg3 ; + std::shared_ptr< SpecUtils::Measurement const > tempnull1 ; + double result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = jarg1 ? *(std::shared_ptr< SpecUtils::Measurement const > **)&jarg1 : &tempnull1; + arg2 = (float)jarg2; + arg3 = (float)jarg3; + result = (double)SpecUtils::gamma_integral((std::shared_ptr< SpecUtils::Measurement const > const &)*arg1,arg2,arg3); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_detectorTypeToString(JNIEnv *jenv, jclass jcls, jint jarg1) { + jstring jresult = 0 ; + SpecUtils::DetectorType arg1 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + arg1 = (SpecUtils::DetectorType)jarg1; + result = (std::string *) &SpecUtils::detectorTypeToString(arg1); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_new_1Measurement(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + SpecUtils::Measurement *result = 0 ; + + (void)jenv; + (void)jcls; + result = (SpecUtils::Measurement *)new SpecUtils::Measurement(); + + *(std::shared_ptr< SpecUtils::Measurement > **)&jresult = result ? new std::shared_ptr< SpecUtils::Measurement >(result SWIG_NO_NULL_DELETER_1) : 0; + + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1operatorEqual(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { + jlong jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + SpecUtils::Measurement *arg2 = 0 ; + std::shared_ptr< SpecUtils::Measurement > *smartarg1 = 0 ; + SpecUtils::Measurement *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + + smartarg1 = *(std::shared_ptr< SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + + arg2 = (SpecUtils::Measurement *)((*(std::shared_ptr< const SpecUtils::Measurement > **)&jarg2) ? (*(std::shared_ptr< const SpecUtils::Measurement > **)&jarg2)->get() : 0); + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "SpecUtils::Measurement const & reference is null"); + return 0; + } + result = (SpecUtils::Measurement *) &(arg1)->operator =((SpecUtils::Measurement const &)*arg2); + *(std::shared_ptr< const SpecUtils::Measurement > **)&jresult = new std::shared_ptr< const SpecUtils::Measurement >(result SWIG_NO_NULL_DELETER_0); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1memmorysize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + size_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = ((SpecUtils::Measurement const *)arg1)->memmorysize(); + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT jfloat JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1live_1time(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jfloat jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + float result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (float)((SpecUtils::Measurement const *)arg1)->live_time(); + jresult = (jfloat)result; + return jresult; +} + + +SWIGEXPORT jfloat JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1real_1time(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jfloat jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + float result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (float)((SpecUtils::Measurement const *)arg1)->real_time(); + jresult = (jfloat)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1contained_1neutron(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (bool)((SpecUtils::Measurement const *)arg1)->contained_neutron(); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1sample_1number(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (int)((SpecUtils::Measurement const *)arg1)->sample_number(); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1title(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (std::string *) &((SpecUtils::Measurement const *)arg1)->title(); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1occupied(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + SpecUtils::OccupancyStatus result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (SpecUtils::OccupancyStatus)((SpecUtils::Measurement const *)arg1)->occupied(); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1gamma_1count_1sum(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jdouble jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + double result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (double)((SpecUtils::Measurement const *)arg1)->gamma_count_sum(); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jfloat JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1neutron_1live_1time(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jfloat jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + float result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (float)((SpecUtils::Measurement const *)arg1)->neutron_live_time(); + jresult = (jfloat)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1neutron_1counts_1sum(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jdouble jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + double result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (double)((SpecUtils::Measurement const *)arg1)->neutron_counts_sum(); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jfloat JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1speed(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jfloat jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + float result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (float)((SpecUtils::Measurement const *)arg1)->speed(); + jresult = (jfloat)result; + return jresult; +} + + +SWIGEXPORT jfloat JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1dx(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jfloat jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + float result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (float)((SpecUtils::Measurement const *)arg1)->dx(); + jresult = (jfloat)result; + return jresult; +} + + +SWIGEXPORT jfloat JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1dy(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jfloat jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + float result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (float)((SpecUtils::Measurement const *)arg1)->dy(); + jresult = (jfloat)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1latitude(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jdouble jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + double result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (double)((SpecUtils::Measurement const *)arg1)->latitude(); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1longitude(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jdouble jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + double result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (double)((SpecUtils::Measurement const *)arg1)->longitude(); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1has_1gps_1info(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (bool)((SpecUtils::Measurement const *)arg1)->has_gps_info(); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jfloat JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1dose_1rate(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jfloat jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + float result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (float)((SpecUtils::Measurement const *)arg1)->dose_rate(); + jresult = (jfloat)result; + return jresult; +} + + +SWIGEXPORT jfloat JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1exposure_1rate(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jfloat jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + float result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (float)((SpecUtils::Measurement const *)arg1)->exposure_rate(); + jresult = (jfloat)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1position_1time(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + SpecUtils::time_point_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = ((SpecUtils::Measurement const *)arg1)->position_time(); + *(SpecUtils::time_point_t **)&jresult = new SpecUtils::time_point_t(result); + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1detector_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (std::string *) &((SpecUtils::Measurement const *)arg1)->detector_name(); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1detector_1number(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (int)((SpecUtils::Measurement const *)arg1)->detector_number(); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1detector_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (std::string *) &((SpecUtils::Measurement const *)arg1)->detector_type(); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1quality_1status(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + SpecUtils::QualityStatus result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (SpecUtils::QualityStatus)((SpecUtils::Measurement const *)arg1)->quality_status(); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1source_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + SpecUtils::SourceType result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (SpecUtils::SourceType)((SpecUtils::Measurement const *)arg1)->source_type(); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1remarks(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + std::vector< std::string > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (std::vector< std::string > *) &((SpecUtils::Measurement const *)arg1)->remarks(); + *(std::vector< std::string > **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1parse_1warnings(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + std::vector< std::string > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (std::vector< std::string > *) &((SpecUtils::Measurement const *)arg1)->parse_warnings(); + *(std::vector< std::string > **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1start_1time(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + SpecUtils::time_point_t *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (SpecUtils::time_point_t *) &((SpecUtils::Measurement const *)arg1)->start_time(); + *(SpecUtils::time_point_t **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1start_1time_1copy(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + SpecUtils::time_point_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = ((SpecUtils::Measurement const *)arg1)->start_time_copy(); + *(SpecUtils::time_point_t **)&jresult = new SpecUtils::time_point_t(result); + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1energy_1calibration_1model(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + SpecUtils::EnergyCalType result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (SpecUtils::EnergyCalType)((SpecUtils::Measurement const *)arg1)->energy_calibration_model(); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1calibration_1coeffs(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + std::vector< float > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (std::vector< float > *) &((SpecUtils::Measurement const *)arg1)->calibration_coeffs(); + *(std::shared_ptr< const std::vector > **)&jresult = new std::shared_ptr< const std::vector >(result SWIG_NO_NULL_DELETER_0); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1deviation_1pairs(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + std::vector< std::pair< float,float > > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (std::vector< std::pair< float,float > > *) &((SpecUtils::Measurement const *)arg1)->deviation_pairs(); + *(std::vector< std::pair< float,float > > **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1energy_1calibration(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + SwigValueWrapper< std::shared_ptr< SpecUtils::EnergyCalibration const > > result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = ((SpecUtils::Measurement const *)arg1)->energy_calibration(); + *(std::shared_ptr< SpecUtils::EnergyCalibration const > **)&jresult = new std::shared_ptr< SpecUtils::EnergyCalibration const >(result); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1channel_1energies(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + std::shared_ptr< std::vector< float > const > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (std::shared_ptr< std::vector< float > const > *) &((SpecUtils::Measurement const *)arg1)->channel_energies(); + *(std::shared_ptr< std::vector< float > const > **)&jresult = *result ? new std::shared_ptr< std::vector< float > const >(*result) : 0; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1gamma_1counts(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + std::shared_ptr< std::vector< float > const > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (std::shared_ptr< std::vector< float > const > *) &((SpecUtils::Measurement const *)arg1)->gamma_counts(); + *(std::shared_ptr< std::vector< float > const > **)&jresult = *result ? new std::shared_ptr< std::vector< float > const >(*result) : 0; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1neutron_1counts(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + std::vector< float > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (std::vector< float > *) &((SpecUtils::Measurement const *)arg1)->neutron_counts(); + *(std::shared_ptr< const std::vector > **)&jresult = new std::shared_ptr< const std::vector >(result SWIG_NO_NULL_DELETER_0); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1location_1state(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + std::shared_ptr< SpecUtils::LocationState const > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (std::shared_ptr< SpecUtils::LocationState const > *) &((SpecUtils::Measurement const *)arg1)->location_state(); + *(std::shared_ptr< SpecUtils::LocationState const > **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1set_1title(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + SpecUtils::Measurement *arg1 = 0 ; + std::string *arg2 = 0 ; + std::shared_ptr< SpecUtils::Measurement > *smartarg1 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + (arg1)->set_title((std::string const &)*arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1set_1start_1time(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SpecUtils::Measurement *arg1 = 0 ; + SpecUtils::time_point_t *arg2 = 0 ; + std::shared_ptr< SpecUtils::Measurement > *smartarg1 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + arg2 = *(SpecUtils::time_point_t **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "SpecUtils::time_point_t const & is null"); + return ; + } + (arg1)->set_start_time((SpecUtils::time_point_t const &)*arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1set_1remarks(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { + SpecUtils::Measurement *arg1 = 0 ; + std::vector< std::string > *arg2 = 0 ; + std::shared_ptr< SpecUtils::Measurement > *smartarg1 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + + smartarg1 = *(std::shared_ptr< SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + arg2 = *(std::vector< std::string > **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::string > const & is null"); + return ; + } + (arg1)->set_remarks((std::vector< std::string > const &)*arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1set_1parse_1warnings(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { + SpecUtils::Measurement *arg1 = 0 ; + std::vector< std::string > *arg2 = 0 ; + std::shared_ptr< SpecUtils::Measurement > *smartarg1 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + + smartarg1 = *(std::shared_ptr< SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + arg2 = *(std::vector< std::string > **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::string > const & is null"); + return ; + } + (arg1)->set_parse_warnings((std::vector< std::string > const &)*arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1set_1source_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + SpecUtils::Measurement *arg1 = 0 ; + SpecUtils::SourceType arg2 ; + std::shared_ptr< SpecUtils::Measurement > *smartarg1 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + arg2 = (SpecUtils::SourceType)jarg2; + (arg1)->set_source_type(arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1set_1position(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2, jdouble jarg3, jlong jarg4) { + SpecUtils::Measurement *arg1 = 0 ; + double arg2 ; + double arg3 ; + SpecUtils::time_point_t arg4 ; + std::shared_ptr< SpecUtils::Measurement > *smartarg1 = 0 ; + SpecUtils::time_point_t *argp4 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + arg2 = (double)jarg2; + arg3 = (double)jarg3; + argp4 = *(SpecUtils::time_point_t **)&jarg4; + if (!argp4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null SpecUtils::time_point_t"); + return ; + } + arg4 = *argp4; + (arg1)->set_position(arg2,arg3,SWIG_STD_MOVE(arg4)); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1set_1sample_1number(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + SpecUtils::Measurement *arg1 = 0 ; + int arg2 ; + std::shared_ptr< SpecUtils::Measurement > *smartarg1 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + arg2 = (int)jarg2; + (arg1)->set_sample_number(arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1set_1occupancy_1status(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + SpecUtils::Measurement *arg1 = 0 ; + SpecUtils::OccupancyStatus arg2 ; + std::shared_ptr< SpecUtils::Measurement > *smartarg1 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + arg2 = (SpecUtils::OccupancyStatus)jarg2; + (arg1)->set_occupancy_status(arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1set_1detector_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + SpecUtils::Measurement *arg1 = 0 ; + std::string *arg2 = 0 ; + std::shared_ptr< SpecUtils::Measurement > *smartarg1 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + (arg1)->set_detector_name((std::string const &)*arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1set_1detector_1number(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + SpecUtils::Measurement *arg1 = 0 ; + int arg2 ; + std::shared_ptr< SpecUtils::Measurement > *smartarg1 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + arg2 = (int)jarg2; + (arg1)->set_detector_number(arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1set_1gamma_1counts(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jfloat jarg3, jfloat jarg4) { + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< std::vector< float > const > arg2 ; + float arg3 ; + float arg4 ; + std::shared_ptr< SpecUtils::Measurement > *smartarg1 = 0 ; + std::shared_ptr< std::vector< float > const > *argp2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + + smartarg1 = *(std::shared_ptr< SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + argp2 = *(std::shared_ptr< std::vector< float > const > **)&jarg2; + if (argp2) arg2 = *argp2; + arg3 = (float)jarg3; + arg4 = (float)jarg4; + (arg1)->set_gamma_counts(SWIG_STD_MOVE(arg2),arg3,arg4); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1set_1neutron_1counts(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jfloat jarg3) { + SpecUtils::Measurement *arg1 = 0 ; + std::vector< float > *arg2 = 0 ; + float arg3 ; + std::shared_ptr< SpecUtils::Measurement > *smartarg1 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + + smartarg1 = *(std::shared_ptr< SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + + arg2 = (std::vector< float > *)((*(std::shared_ptr< const std::vector > **)&jarg2) ? (*(std::shared_ptr< const std::vector > **)&jarg2)->get() : 0); + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< float > const & reference is null"); + return ; + } + arg3 = (float)jarg3; + (arg1)->set_neutron_counts((std::vector< float > const &)*arg2,arg3); +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1num_1gamma_1channels(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + size_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = ((SpecUtils::Measurement const *)arg1)->num_gamma_channels(); + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1find_1gamma_1channel(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { + jlong jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + float arg2 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + size_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + arg2 = (float)jarg2; + result = ((SpecUtils::Measurement const *)arg1)->find_gamma_channel(arg2); + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT jfloat JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1gamma_1channel_1content(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jfloat jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + size_t arg2 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + float result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + arg2 = (size_t)jarg2; + result = (float)((SpecUtils::Measurement const *)arg1)->gamma_channel_content(SWIG_STD_MOVE(arg2)); + jresult = (jfloat)result; + return jresult; +} + + +SWIGEXPORT jfloat JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1gamma_1channel_1lower(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jfloat jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + size_t arg2 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + float result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + arg2 = (size_t)jarg2; + result = (float)((SpecUtils::Measurement const *)arg1)->gamma_channel_lower(SWIG_STD_MOVE(arg2)); + jresult = (jfloat)result; + return jresult; +} + + +SWIGEXPORT jfloat JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1gamma_1channel_1center(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jfloat jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + size_t arg2 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + float result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + arg2 = (size_t)jarg2; + result = (float)((SpecUtils::Measurement const *)arg1)->gamma_channel_center(SWIG_STD_MOVE(arg2)); + jresult = (jfloat)result; + return jresult; +} + + +SWIGEXPORT jfloat JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1gamma_1channel_1upper(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jfloat jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + size_t arg2 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + float result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + arg2 = (size_t)jarg2; + result = (float)((SpecUtils::Measurement const *)arg1)->gamma_channel_upper(SWIG_STD_MOVE(arg2)); + jresult = (jfloat)result; + return jresult; +} + + +SWIGEXPORT jfloat JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1gamma_1channel_1width(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jfloat jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + size_t arg2 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + float result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + arg2 = (size_t)jarg2; + result = (float)((SpecUtils::Measurement const *)arg1)->gamma_channel_width(SWIG_STD_MOVE(arg2)); + jresult = (jfloat)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1gamma_1integral(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jfloat jarg3) { + jdouble jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + float arg2 ; + float arg3 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + double result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + arg2 = (float)jarg2; + arg3 = (float)jarg3; + result = (double)((SpecUtils::Measurement const *)arg1)->gamma_integral(arg2,arg3); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1gamma_1channels_1sum(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3) { + jdouble jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + size_t arg2 ; + size_t arg3 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + double result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + arg2 = (size_t)jarg2; + arg3 = (size_t)jarg3; + result = (double)((SpecUtils::Measurement const *)arg1)->gamma_channels_sum(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1gamma_1channel_1energies(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + std::shared_ptr< std::vector< float > const > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (std::shared_ptr< std::vector< float > const > *) &((SpecUtils::Measurement const *)arg1)->gamma_channel_energies(); + *(std::shared_ptr< std::vector< float > const > **)&jresult = *result ? new std::shared_ptr< std::vector< float > const >(*result) : 0; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1gamma_1channel_1contents(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + std::shared_ptr< std::vector< float > const > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (std::shared_ptr< std::vector< float > const > *) &((SpecUtils::Measurement const *)arg1)->gamma_channel_contents(); + *(std::shared_ptr< std::vector< float > const > **)&jresult = *result ? new std::shared_ptr< std::vector< float > const >(*result) : 0; + return jresult; +} + + +SWIGEXPORT jfloat JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1gamma_1energy_1min(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jfloat jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + float result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (float)((SpecUtils::Measurement const *)arg1)->gamma_energy_min(); + jresult = (jfloat)result; + return jresult; +} + + +SWIGEXPORT jfloat JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1gamma_1energy_1max(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jfloat jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + float result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = (float)((SpecUtils::Measurement const *)arg1)->gamma_energy_max(); + jresult = (jfloat)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1DerivedDataProperties_1IsDerived_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SpecUtils::Measurement::DerivedDataProperties result; + + (void)jenv; + (void)jcls; + result = (SpecUtils::Measurement::DerivedDataProperties)SpecUtils::Measurement::DerivedDataProperties::IsDerived; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1DerivedDataProperties_1ItemOfInterestSum_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SpecUtils::Measurement::DerivedDataProperties result; + + (void)jenv; + (void)jcls; + result = (SpecUtils::Measurement::DerivedDataProperties)SpecUtils::Measurement::DerivedDataProperties::ItemOfInterestSum; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1DerivedDataProperties_1UsedForAnalysis_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SpecUtils::Measurement::DerivedDataProperties result; + + (void)jenv; + (void)jcls; + result = (SpecUtils::Measurement::DerivedDataProperties)SpecUtils::Measurement::DerivedDataProperties::UsedForAnalysis; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1DerivedDataProperties_1ProcessedFurther_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SpecUtils::Measurement::DerivedDataProperties result; + + (void)jenv; + (void)jcls; + result = (SpecUtils::Measurement::DerivedDataProperties)SpecUtils::Measurement::DerivedDataProperties::ProcessedFurther; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1DerivedDataProperties_1BackgroundSubtracted_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SpecUtils::Measurement::DerivedDataProperties result; + + (void)jenv; + (void)jcls; + result = (SpecUtils::Measurement::DerivedDataProperties)SpecUtils::Measurement::DerivedDataProperties::BackgroundSubtracted; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1DerivedDataProperties_1IsBackground_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SpecUtils::Measurement::DerivedDataProperties result; + + (void)jenv; + (void)jcls; + result = (SpecUtils::Measurement::DerivedDataProperties)SpecUtils::Measurement::DerivedDataProperties::IsBackground; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1derived_1data_1properties(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + uint32_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + result = ((SpecUtils::Measurement const *)arg1)->derived_data_properties(); + *(uint32_t **)&jresult = new uint32_t(result); + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1write_12006_1N42_1xml(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::ostream *arg2 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + arg2 = *(std::ostream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::ostream & is null"); + return 0; + } + result = (bool)((SpecUtils::Measurement const *)arg1)->write_2006_N42_xml(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1write_1csv(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::ostream *arg2 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + arg2 = *(std::ostream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::ostream & is null"); + return 0; + } + result = (bool)((SpecUtils::Measurement const *)arg1)->write_csv(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1write_1txt(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::Measurement *arg1 = 0 ; + std::ostream *arg2 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *smartarg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< const SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + arg2 = *(std::ostream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::ostream & is null"); + return 0; + } + result = (bool)((SpecUtils::Measurement const *)arg1)->write_txt(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1reset(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement > *smartarg1 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + (arg1)->reset(); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1combine_1gamma_1channels(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SpecUtils::Measurement *arg1 = 0 ; + size_t arg2 ; + std::shared_ptr< SpecUtils::Measurement > *smartarg1 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + arg2 = (size_t)jarg2; + (arg1)->combine_gamma_channels(SWIG_STD_MOVE(arg2)); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1truncate_1gamma_1channels(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jboolean jarg4) { + SpecUtils::Measurement *arg1 = 0 ; + size_t arg2 ; + size_t arg3 ; + bool arg4 ; + std::shared_ptr< SpecUtils::Measurement > *smartarg1 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + arg2 = (size_t)jarg2; + arg3 = (size_t)jarg3; + arg4 = jarg4 ? true : false; + (arg1)->truncate_gamma_channels(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1rebin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::EnergyCalibration const > *arg2 = 0 ; + std::shared_ptr< SpecUtils::Measurement > *smartarg1 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + arg2 = *(std::shared_ptr< SpecUtils::EnergyCalibration const > **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::shared_ptr< SpecUtils::EnergyCalibration const > const & is null"); + return ; + } + (arg1)->rebin((std::shared_ptr< SpecUtils::EnergyCalibration const > const &)*arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1set_1energy_1calibration(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::EnergyCalibration const > *arg2 = 0 ; + std::shared_ptr< SpecUtils::Measurement > *smartarg1 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + arg2 = *(std::shared_ptr< SpecUtils::EnergyCalibration const > **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::shared_ptr< SpecUtils::EnergyCalibration const > const & is null"); + return ; + } + (arg1)->set_energy_calibration((std::shared_ptr< SpecUtils::EnergyCalibration const > const &)*arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_Measurement_1set_1info_1from_12006_1N42_1spectrum_1node(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SpecUtils::Measurement *arg1 = 0 ; + rapidxml::xml_node< char > *arg2 = (rapidxml::xml_node< char > *)0 ; + std::shared_ptr< SpecUtils::Measurement > *smartarg1 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + smartarg1 = *(std::shared_ptr< SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + arg2 = *(rapidxml::xml_node< char > **)&jarg2; + (arg1)->set_info_from_2006_N42_spectrum_node((rapidxml::xml_node< char > const *)arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_delete_1Measurement(JNIEnv *jenv, jclass jcls, jlong jarg1) { + SpecUtils::Measurement *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement > *smartarg1 = 0 ; + + (void)jenv; + (void)jcls; + + smartarg1 = *(std::shared_ptr< SpecUtils::Measurement > **)&jarg1; + arg1 = (SpecUtils::Measurement *)(smartarg1 ? smartarg1->get() : 0); + (void)arg1; delete smartarg1; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_new_1SpecFile_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + SpecUtils::SpecFile *result = 0 ; + + (void)jenv; + (void)jcls; + result = (SpecUtils::SpecFile *)new SpecUtils::SpecFile(); + *(SpecUtils::SpecFile **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_new_1SpecFile_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + SpecUtils::SpecFile *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if (!arg1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "SpecUtils::SpecFile const & is null"); + return 0; + } + result = (SpecUtils::SpecFile *)new SpecUtils::SpecFile((SpecUtils::SpecFile const &)*arg1); + *(SpecUtils::SpecFile **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_delete_1SpecFile(JNIEnv *jenv, jclass jcls, jlong jarg1) { + SpecUtils::SpecFile *arg1 = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + delete arg1; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1operatorEqual(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + SpecUtils::SpecFile *arg2 = 0 ; + SpecUtils::SpecFile *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(SpecUtils::SpecFile **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "SpecUtils::SpecFile const & is null"); + return 0; + } + result = (SpecUtils::SpecFile *) &(arg1)->operator =((SpecUtils::SpecFile const &)*arg2); + *(SpecUtils::SpecFile **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3, jstring jarg4) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + SpecUtils::ParserType arg3 ; + std::string arg4 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return 0; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + arg3 = (SpecUtils::ParserType)jarg3; + if(!jarg4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg4_pstr = jenv->GetStringUTFChars(jarg4, 0); + if (!arg4_pstr) return 0; + (&arg4)->assign(arg4_pstr); + jenv->ReleaseStringUTFChars(jarg4, arg4_pstr); + result = (bool)(arg1)->load_file((std::string const &)*arg2,arg3,SWIG_STD_MOVE(arg4)); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1parse_1warnings(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::vector< std::string > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (std::vector< std::string > *) &((SpecUtils::SpecFile const *)arg1)->parse_warnings(); + *(std::vector< std::string > **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1modified(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (bool)((SpecUtils::SpecFile const *)arg1)->modified(); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1reset_1modified(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + SpecUtils::SpecFile *arg1 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + (arg1)->reset_modified(); +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1modified_1since_1decode(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (bool)((SpecUtils::SpecFile const *)arg1)->modified_since_decode(); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1reset_1modified_1since_1decode(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + SpecUtils::SpecFile *arg1 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + (arg1)->reset_modified_since_decode(); +} + + +SWIGEXPORT jfloat JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1gamma_1live_1time(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jfloat jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + float result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (float)((SpecUtils::SpecFile const *)arg1)->gamma_live_time(); + jresult = (jfloat)result; + return jresult; +} + + +SWIGEXPORT jfloat JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1gamma_1real_1time(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jfloat jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + float result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (float)((SpecUtils::SpecFile const *)arg1)->gamma_real_time(); + jresult = (jfloat)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1gamma_1count_1sum(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jdouble jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + double result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (double)((SpecUtils::SpecFile const *)arg1)->gamma_count_sum(); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1neutron_1counts_1sum(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jdouble jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + double result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (double)((SpecUtils::SpecFile const *)arg1)->neutron_counts_sum(); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1filename(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (std::string *) &((SpecUtils::SpecFile const *)arg1)->filename(); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1detector_1names(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::vector< std::string > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (std::vector< std::string > *) &((SpecUtils::SpecFile const *)arg1)->detector_names(); + *(std::vector< std::string > **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1detector_1numbers(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::vector< int > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (std::vector< int > *) &((SpecUtils::SpecFile const *)arg1)->detector_numbers(); + *(std::vector< int > **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1gamma_1detector_1names(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::vector< std::string > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (std::vector< std::string > *) &((SpecUtils::SpecFile const *)arg1)->gamma_detector_names(); + *(std::vector< std::string > **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1neutron_1detector_1names(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::vector< std::string > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (std::vector< std::string > *) &((SpecUtils::SpecFile const *)arg1)->neutron_detector_names(); + *(std::vector< std::string > **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1uuid(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (std::string *) &((SpecUtils::SpecFile const *)arg1)->uuid(); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1remarks(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::vector< std::string > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (std::vector< std::string > *) &((SpecUtils::SpecFile const *)arg1)->remarks(); + *(std::vector< std::string > **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1lane_1number(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (int)((SpecUtils::SpecFile const *)arg1)->lane_number(); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1measurement_1location_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (std::string *) &((SpecUtils::SpecFile const *)arg1)->measurement_location_name(); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1inspection(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (std::string *) &((SpecUtils::SpecFile const *)arg1)->inspection(); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1measurement_1operator(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (std::string *) &((SpecUtils::SpecFile const *)arg1)->measurement_operator(); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1sample_1numbers(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::set< int > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (std::set< int > *) &((SpecUtils::SpecFile const *)arg1)->sample_numbers(); + *(std::set< int > **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1num_1measurements(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + size_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = ((SpecUtils::SpecFile const *)arg1)->num_measurements(); + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1detector_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + SpecUtils::DetectorType result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (SpecUtils::DetectorType)((SpecUtils::SpecFile const *)arg1)->detector_type(); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1instrument_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (std::string *) &((SpecUtils::SpecFile const *)arg1)->instrument_type(); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1manufacturer(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (std::string *) &((SpecUtils::SpecFile const *)arg1)->manufacturer(); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1instrument_1model(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (std::string *) &((SpecUtils::SpecFile const *)arg1)->instrument_model(); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1instrument_1id(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (std::string *) &((SpecUtils::SpecFile const *)arg1)->instrument_id(); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1measurements(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + SwigValueWrapper< std::vector< std::shared_ptr< SpecUtils::Measurement const > > > result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = ((SpecUtils::SpecFile const *)arg1)->measurements(); + *(std::vector< std::shared_ptr< SpecUtils::Measurement const > > **)&jresult = new std::vector< std::shared_ptr< SpecUtils::Measurement const > >(result); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1measurement_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + size_t arg2 ; + std::shared_ptr< SpecUtils::Measurement const > result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = (size_t)jarg2; + result = ((SpecUtils::SpecFile const *)arg1)->measurement(SWIG_STD_MOVE(arg2)); + *(std::shared_ptr< SpecUtils::Measurement const > **)&jresult = result ? new std::shared_ptr< SpecUtils::Measurement const >(result) : 0; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1detectors_1analysis(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + SwigValueWrapper< std::shared_ptr< SpecUtils::DetectorAnalysis const > > result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = ((SpecUtils::SpecFile const *)arg1)->detectors_analysis(); + *(std::shared_ptr< SpecUtils::DetectorAnalysis const > **)&jresult = new std::shared_ptr< SpecUtils::DetectorAnalysis const >(result); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1multimedia_1data(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::vector< std::shared_ptr< SpecUtils::MultimediaData const > > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (std::vector< std::shared_ptr< SpecUtils::MultimediaData const > > *) &((SpecUtils::SpecFile const *)arg1)->multimedia_data(); + *(std::vector< std::shared_ptr< SpecUtils::MultimediaData const > > **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1has_1gps_1info(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (bool)((SpecUtils::SpecFile const *)arg1)->has_gps_info(); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1mean_1latitude(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jdouble jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + double result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (double)((SpecUtils::SpecFile const *)arg1)->mean_latitude(); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1mean_1longitude(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jdouble jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + double result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (double)((SpecUtils::SpecFile const *)arg1)->mean_longitude(); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1passthrough(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (bool)((SpecUtils::SpecFile const *)arg1)->passthrough(); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1contains_1derived_1data(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (bool)((SpecUtils::SpecFile const *)arg1)->contains_derived_data(); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1contains_1non_1derived_1data(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (bool)((SpecUtils::SpecFile const *)arg1)->contains_non_derived_data(); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1set_1filename(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + (arg1)->set_filename((std::string const &)*arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1set_1remarks_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { + SpecUtils::SpecFile *arg1 = 0 ; + std::vector< std::string > *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::vector< std::string > **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::string > const & is null"); + return ; + } + (arg1)->set_remarks((std::vector< std::string > const &)*arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1add_1remark(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + (arg1)->add_remark((std::string const &)*arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1set_1parse_1warnings(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { + SpecUtils::SpecFile *arg1 = 0 ; + std::vector< std::string > *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::vector< std::string > **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::string > const & is null"); + return ; + } + (arg1)->set_parse_warnings((std::vector< std::string > const &)*arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1set_1uuid(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + (arg1)->set_uuid((std::string const &)*arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1set_1lane_1number(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + SpecUtils::SpecFile *arg1 = 0 ; + int arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = (int)jarg2; + (arg1)->set_lane_number(arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1set_1measurement_1location_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + (arg1)->set_measurement_location_name((std::string const &)*arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1set_1inspection(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + (arg1)->set_inspection((std::string const &)*arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1set_1instrument_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + (arg1)->set_instrument_type((std::string const &)*arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1set_1detector_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + SpecUtils::SpecFile *arg1 = 0 ; + SpecUtils::DetectorType arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = (SpecUtils::DetectorType)jarg2; + (arg1)->set_detector_type(arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1set_1manufacturer(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + (arg1)->set_manufacturer((std::string const &)*arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1set_1instrument_1model(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + (arg1)->set_instrument_model((std::string const &)*arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1set_1instrument_1id(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + (arg1)->set_instrument_id((std::string const &)*arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1set_1live_1time(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jlong jarg3, jobject jarg3_) { + SpecUtils::SpecFile *arg1 = 0 ; + float arg2 ; + std::shared_ptr< SpecUtils::Measurement const > arg3 ; + std::shared_ptr< SpecUtils::Measurement const > *argp3 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg3_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = (float)jarg2; + argp3 = *(std::shared_ptr< SpecUtils::Measurement const > **)&jarg3; + if (argp3) arg3 = *argp3; + (arg1)->set_live_time(arg2,SWIG_STD_MOVE(arg3)); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1set_1real_1time(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2, jlong jarg3, jobject jarg3_) { + SpecUtils::SpecFile *arg1 = 0 ; + float arg2 ; + std::shared_ptr< SpecUtils::Measurement const > arg3 ; + std::shared_ptr< SpecUtils::Measurement const > *argp3 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg3_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = (float)jarg2; + argp3 = *(std::shared_ptr< SpecUtils::Measurement const > **)&jarg3; + if (argp3) arg3 = *argp3; + (arg1)->set_real_time(arg2,SWIG_STD_MOVE(arg3)); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1set_1start_1time(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jobject jarg3_) { + SpecUtils::SpecFile *arg1 = 0 ; + SpecUtils::time_point_t *arg2 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > arg3 ; + std::shared_ptr< SpecUtils::Measurement const > const *argp3 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg3_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(SpecUtils::time_point_t **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "SpecUtils::time_point_t const & is null"); + return ; + } + argp3 = *(std::shared_ptr< SpecUtils::Measurement const > **)&jarg3; + if (argp3) arg3 = *argp3; + (arg1)->set_start_time((SpecUtils::time_point_t const &)*arg2,SWIG_STD_MOVE(arg3)); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1set_1remarks_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) { + SpecUtils::SpecFile *arg1 = 0 ; + std::vector< std::string > *arg2 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > arg3 ; + std::shared_ptr< SpecUtils::Measurement const > const *argp3 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + (void)jarg3_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::vector< std::string > **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::string > const & is null"); + return ; + } + argp3 = *(std::shared_ptr< SpecUtils::Measurement const > **)&jarg3; + if (argp3) arg3 = *argp3; + (arg1)->set_remarks((std::vector< std::string > const &)*arg2,SWIG_STD_MOVE(arg3)); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1set_1source_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) { + SpecUtils::SpecFile *arg1 = 0 ; + SpecUtils::SourceType arg2 ; + std::shared_ptr< SpecUtils::Measurement const > arg3 ; + std::shared_ptr< SpecUtils::Measurement const > const *argp3 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg3_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = (SpecUtils::SourceType)jarg2; + argp3 = *(std::shared_ptr< SpecUtils::Measurement const > **)&jarg3; + if (argp3) arg3 = *argp3; + (arg1)->set_source_type(arg2,SWIG_STD_MOVE(arg3)); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1set_1position(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2, jdouble jarg3, jlong jarg4, jlong jarg5, jobject jarg5_) { + SpecUtils::SpecFile *arg1 = 0 ; + double arg2 ; + double arg3 ; + SpecUtils::time_point_t arg4 ; + std::shared_ptr< SpecUtils::Measurement const > arg5 ; + SpecUtils::time_point_t *argp4 ; + std::shared_ptr< SpecUtils::Measurement const > const *argp5 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg5_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = (double)jarg2; + arg3 = (double)jarg3; + argp4 = *(SpecUtils::time_point_t **)&jarg4; + if (!argp4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null SpecUtils::time_point_t"); + return ; + } + arg4 = *argp4; + argp5 = *(std::shared_ptr< SpecUtils::Measurement const > **)&jarg5; + if (argp5) arg5 = *argp5; + (arg1)->set_position(arg2,arg3,SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5)); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1set_1title(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_) { + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > arg3 ; + std::shared_ptr< SpecUtils::Measurement const > const *argp3 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg3_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + argp3 = *(std::shared_ptr< SpecUtils::Measurement const > **)&jarg3; + if (argp3) arg3 = *argp3; + (arg1)->set_title((std::string const &)*arg2,SWIG_STD_MOVE(arg3)); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1set_1contained_1neutrons(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2, jfloat jarg3, jlong jarg4, jobject jarg4_, jfloat jarg5) { + SpecUtils::SpecFile *arg1 = 0 ; + bool arg2 ; + float arg3 ; + std::shared_ptr< SpecUtils::Measurement const > arg4 ; + float arg5 ; + std::shared_ptr< SpecUtils::Measurement const > const *argp4 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg4_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = jarg2 ? true : false; + arg3 = (float)jarg3; + argp4 = *(std::shared_ptr< SpecUtils::Measurement const > **)&jarg4; + if (argp4) arg4 = *argp4; + arg5 = (float)jarg5; + (arg1)->set_contained_neutrons(arg2,arg3,SWIG_STD_MOVE(arg4),arg5); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1set_1detectors_1analysis(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { + SpecUtils::SpecFile *arg1 = 0 ; + SpecUtils::DetectorAnalysis *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(SpecUtils::DetectorAnalysis **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "SpecUtils::DetectorAnalysis const & is null"); + return ; + } + (arg1)->set_detectors_analysis((SpecUtils::DetectorAnalysis const &)*arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1change_1detector_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) { + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + if(!jarg3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); + if (!arg3_pstr) return ; + std::string arg3_str(arg3_pstr); + arg3 = &arg3_str; + jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); + (arg1)->change_detector_name((std::string const &)*arg2,(std::string const &)*arg3); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1change_1sample_1numbers(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SpecUtils::SpecFile *arg1 = 0 ; + std::vector< std::pair< int,int > > *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::vector< std::pair< int,int > > **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< int,int > > const & is null"); + return ; + } + (arg1)->change_sample_numbers((std::vector< std::pair< int,int > > const &)*arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1add_1measurement(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jboolean jarg3) { + SpecUtils::SpecFile *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement > arg2 ; + bool arg3 ; + std::shared_ptr< SpecUtils::Measurement > *argp2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + argp2 = *(std::shared_ptr< SpecUtils::Measurement > **)&jarg2; + if (argp2) arg2 = *argp2; + arg3 = jarg3 ? true : false; + (arg1)->add_measurement(SWIG_STD_MOVE(arg2),arg3); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1remove_1measurement(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jboolean jarg3) { + SpecUtils::SpecFile *arg1 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > arg2 ; + bool arg3 ; + std::shared_ptr< SpecUtils::Measurement const > *argp2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + argp2 = *(std::shared_ptr< SpecUtils::Measurement const > **)&jarg2; + if (argp2) arg2 = *argp2; + arg3 = jarg3 ? true : false; + (arg1)->remove_measurement(SWIG_STD_MOVE(arg2),arg3); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1remove_1measurements(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SpecUtils::SpecFile *arg1 = 0 ; + std::vector< std::shared_ptr< SpecUtils::Measurement const > > *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::vector< std::shared_ptr< SpecUtils::Measurement const > > **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::shared_ptr< SpecUtils::Measurement const > > const & is null"); + return ; + } + (arg1)->remove_measurements((std::vector< std::shared_ptr< SpecUtils::Measurement const > > const &)*arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1clear_1multimedia_1data(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + SpecUtils::SpecFile *arg1 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + (arg1)->clear_multimedia_data(); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1add_1multimedia_1data(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { + SpecUtils::SpecFile *arg1 = 0 ; + SpecUtils::MultimediaData *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(SpecUtils::MultimediaData **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "SpecUtils::MultimediaData const & is null"); + return ; + } + (arg1)->add_multimedia_data((SpecUtils::MultimediaData const &)*arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1set_1multimedia_1data(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SpecUtils::SpecFile *arg1 = 0 ; + std::vector< std::shared_ptr< SpecUtils::MultimediaData const > > *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::vector< std::shared_ptr< SpecUtils::MultimediaData const > > **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::shared_ptr< SpecUtils::MultimediaData const > > & is null"); + return ; + } + (arg1)->set_multimedia_data(*arg2); +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1combine_1gamma_1channels_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + size_t arg2 ; + size_t arg3 ; + size_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = (size_t)jarg2; + arg3 = (size_t)jarg3; + result = (arg1)->combine_gamma_channels(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3)); + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1combine_1gamma_1channels_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jobject jarg3_) { + SpecUtils::SpecFile *arg1 = 0 ; + size_t arg2 ; + std::shared_ptr< SpecUtils::Measurement const > *arg3 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > tempnull3 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg3_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = (size_t)jarg2; + arg3 = jarg3 ? *(std::shared_ptr< SpecUtils::Measurement const > **)&jarg3 : &tempnull3; + (arg1)->combine_gamma_channels(SWIG_STD_MOVE(arg2),(std::shared_ptr< SpecUtils::Measurement const > const &)*arg3); +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1truncate_1gamma_1channels_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jboolean jarg5) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + size_t arg2 ; + size_t arg3 ; + size_t arg4 ; + bool arg5 ; + size_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = (size_t)jarg2; + arg3 = (size_t)jarg3; + arg4 = (size_t)jarg4; + arg5 = jarg5 ? true : false; + result = (arg1)->truncate_gamma_channels(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),arg5); + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1truncate_1gamma_1channels_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jboolean jarg4, jlong jarg5, jobject jarg5_) { + SpecUtils::SpecFile *arg1 = 0 ; + size_t arg2 ; + size_t arg3 ; + bool arg4 ; + std::shared_ptr< SpecUtils::Measurement const > *arg5 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > tempnull5 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg5_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = (size_t)jarg2; + arg3 = (size_t)jarg3; + arg4 = jarg4 ? true : false; + arg5 = jarg5 ? *(std::shared_ptr< SpecUtils::Measurement const > **)&jarg5 : &tempnull5; + (arg1)->truncate_gamma_channels(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,(std::shared_ptr< SpecUtils::Measurement const > const &)*arg5); +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1occupancy_1number_1from_1remarks(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (int)((SpecUtils::SpecFile const *)arg1)->occupancy_number_from_remarks(); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1sample_1measurements(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + int arg2 ; + SwigValueWrapper< std::vector< std::shared_ptr< SpecUtils::Measurement const > > > result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = (int)jarg2; + result = ((SpecUtils::SpecFile const *)arg1)->sample_measurements(arg2); + *(std::vector< std::shared_ptr< SpecUtils::Measurement const > > **)&jresult = new std::vector< std::shared_ptr< SpecUtils::Measurement const > >(result); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1measurement_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jstring jarg3) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + int arg2 ; + std::string *arg3 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = (int)jarg2; + if(!jarg3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); + if (!arg3_pstr) return 0; + std::string arg3_str(arg3_pstr); + arg3 = &arg3_str; + jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); + result = ((SpecUtils::SpecFile const *)arg1)->measurement(arg2,(std::string const &)*arg3); + *(std::shared_ptr< SpecUtils::Measurement const > **)&jresult = result ? new std::shared_ptr< SpecUtils::Measurement const >(result) : 0; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1measurement_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + int arg2 ; + int arg3 ; + std::shared_ptr< SpecUtils::Measurement const > result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = (int)jarg2; + arg3 = (int)jarg3; + result = ((SpecUtils::SpecFile const *)arg1)->measurement(arg2,arg3); + *(std::shared_ptr< SpecUtils::Measurement const > **)&jresult = result ? new std::shared_ptr< SpecUtils::Measurement const >(result) : 0; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1suggested_1sum_1energy_1calibration(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jobject jarg3_) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::set< int > *arg2 = 0 ; + std::vector< std::string > *arg3 = 0 ; + SwigValueWrapper< std::shared_ptr< SpecUtils::EnergyCalibration const > > result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg3_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::set< int > **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::set< int > const & is null"); + return 0; + } + arg3 = *(std::vector< std::string > **)&jarg3; + if (!arg3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::string > const & is null"); + return 0; + } + result = ((SpecUtils::SpecFile const *)arg1)->suggested_sum_energy_calibration((std::set< int > const &)*arg2,(std::vector< std::string > const &)*arg3); + *(std::shared_ptr< SpecUtils::EnergyCalibration const > **)&jresult = new std::shared_ptr< SpecUtils::EnergyCalibration const >(result); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1sum_1measurements(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jobject jarg3_, jlong jarg4) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::set< int > *arg2 = 0 ; + std::vector< std::string > *arg3 = 0 ; + SwigValueWrapper< std::shared_ptr< SpecUtils::EnergyCalibration const > > arg4 ; + std::shared_ptr< SpecUtils::EnergyCalibration const > *argp4 ; + std::shared_ptr< SpecUtils::Measurement > result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg3_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::set< int > **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::set< int > const & is null"); + return 0; + } + arg3 = *(std::vector< std::string > **)&jarg3; + if (!arg3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::string > const & is null"); + return 0; + } + argp4 = *(std::shared_ptr< SpecUtils::EnergyCalibration const > **)&jarg4; + if (!argp4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::shared_ptr< SpecUtils::EnergyCalibration const >"); + return 0; + } + arg4 = *argp4; + result = ((SpecUtils::SpecFile const *)arg1)->sum_measurements((std::set< int > const &)*arg2,(std::vector< std::string > const &)*arg3,SWIG_STD_MOVE(arg4)); + *(std::shared_ptr< SpecUtils::Measurement > **)&jresult = result ? new std::shared_ptr< SpecUtils::Measurement >(result) : 0; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1memmorysize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + size_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = ((SpecUtils::SpecFile const *)arg1)->memmorysize(); + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1gamma_1channel_1counts(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::set< size_t > result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = ((SpecUtils::SpecFile const *)arg1)->gamma_channel_counts(); + *(std::set< size_t > **)&jresult = new std::set< size_t >(result); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1num_1gamma_1channels(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + size_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = ((SpecUtils::SpecFile const *)arg1)->num_gamma_channels(); + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1keep_1n_1bin_1spectra_1only(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + size_t arg2 ; + size_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = (size_t)jarg2; + result = (arg1)->keep_n_bin_spectra_only(SWIG_STD_MOVE(arg2)); + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1contained_1neutron(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (bool)((SpecUtils::SpecFile const *)arg1)->contained_neutron(); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1energy_1cal_1variants(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + SwigValueWrapper< std::set< std::string > > result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = ((SpecUtils::SpecFile const *)arg1)->energy_cal_variants(); + *(std::set< std::string > **)&jresult = new std::set< std::string >(result); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1keep_1energy_1cal_1variants(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::set< std::string > *arg2 = 0 ; + size_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::set< std::string > **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::set< std::string > const & is null"); + return 0; + } + result = (arg1)->keep_energy_cal_variants((std::set< std::string > const &)*arg2); + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1keep_1derived_1data_1variant(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + SpecUtils::SpecFile::DerivedVariantToKeep arg2 ; + size_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = (SpecUtils::SpecFile::DerivedVariantToKeep)jarg2; + result = (arg1)->keep_derived_data_variant(arg2); + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1remove_1detectors_1data(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::set< std::string > *arg2 = 0 ; + size_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::set< std::string > **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::set< std::string > const & is null"); + return 0; + } + result = (arg1)->remove_detectors_data((std::set< std::string > const &)*arg2); + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1remove_1neutron_1measurements(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + size_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (arg1)->remove_neutron_measurements(); + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1background_1sample_1number(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + int result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (int)((SpecUtils::SpecFile const *)arg1)->background_sample_number(); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1generate_1psuedo_1uuid(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = ((SpecUtils::SpecFile const *)arg1)->generate_psuedo_uuid(); + jresult = jenv->NewStringUTF((&result)->c_str()); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1reset(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + SpecUtils::SpecFile *arg1 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + (arg1)->reset(); +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1N42_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return 0; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + result = (bool)(arg1)->load_N42_file((std::string const &)*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1pcf_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return 0; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + result = (bool)(arg1)->load_pcf_file((std::string const &)*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1spc_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return 0; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + result = (bool)(arg1)->load_spc_file((std::string const &)*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1chn_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return 0; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + result = (bool)(arg1)->load_chn_file((std::string const &)*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1iaea_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return 0; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + result = (bool)(arg1)->load_iaea_file((std::string const &)*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1binary_1exploranium_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return 0; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + result = (bool)(arg1)->load_binary_exploranium_file((std::string const &)*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1micro_1raider_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return 0; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + result = (bool)(arg1)->load_micro_raider_file((std::string const &)*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1txt_1or_1csv_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return 0; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + result = (bool)(arg1)->load_txt_or_csv_file((std::string const &)*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1cnf_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return 0; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + result = (bool)(arg1)->load_cnf_file((std::string const &)*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1tracs_1mps_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return 0; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + result = (bool)(arg1)->load_tracs_mps_file((std::string const &)*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1aram_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return 0; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + result = (bool)(arg1)->load_aram_file((std::string const &)*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1spectroscopic_1daily_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return 0; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + result = (bool)(arg1)->load_spectroscopic_daily_file((std::string const &)*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1amptek_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return 0; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + result = (bool)(arg1)->load_amptek_file((std::string const &)*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1ortec_1listmode_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return 0; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + result = (bool)(arg1)->load_ortec_listmode_file((std::string const &)*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1lsrm_1spe_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return 0; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + result = (bool)(arg1)->load_lsrm_spe_file((std::string const &)*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1tka_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return 0; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + result = (bool)(arg1)->load_tka_file((std::string const &)*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1multiact_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return 0; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + result = (bool)(arg1)->load_multiact_file((std::string const &)*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1phd_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return 0; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + result = (bool)(arg1)->load_phd_file((std::string const &)*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1lzs_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return 0; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + result = (bool)(arg1)->load_lzs_file((std::string const &)*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1radiacode_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return 0; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + result = (bool)(arg1)->load_radiacode_file((std::string const &)*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1xml_1scan_1data_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return 0; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + result = (bool)(arg1)->load_xml_scan_data_file((std::string const &)*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1json_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return 0; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + result = (bool)(arg1)->load_json_file((std::string const &)*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1caen_1gxml_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return 0; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + result = (bool)(arg1)->load_caen_gxml_file((std::string const &)*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1from_1N42(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::istream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::istream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::istream & is null"); + return 0; + } + result = (bool)(arg1)->load_from_N42(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1N42_1from_1data_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + char *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + result = (bool)(arg1)->load_N42_from_data(arg2); + jresult = (jboolean)result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1N42_1from_1data_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + char *arg2 = 0 ; + char *arg3 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + arg3 = 0; + if (jarg3) { + arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0); + if (!arg3) return 0; + } + result = (bool)(arg1)->load_N42_from_data(arg2,arg3); + jresult = (jboolean)result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3); + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1from_1iaea_1spc(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::istream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::istream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::istream & is null"); + return 0; + } + result = (bool)(arg1)->load_from_iaea_spc(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1from_1binary_1spc(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::istream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::istream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::istream & is null"); + return 0; + } + result = (bool)(arg1)->load_from_binary_spc(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1from_1N42_1document(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + rapidxml::xml_node< char > *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(rapidxml::xml_node< char > **)&jarg2; + result = (bool)(arg1)->load_from_N42_document((rapidxml::xml_node< char > const *)arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1from_1micro_1raider_1from_1data(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + char *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = 0; + if (jarg2) { + arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0); + if (!arg2) return 0; + } + result = (bool)(arg1)->load_from_micro_raider_from_data((char const *)arg2); + jresult = (jboolean)result; + if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2); + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1from_1binary_1exploranium(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::istream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::istream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::istream & is null"); + return 0; + } + result = (bool)(arg1)->load_from_binary_exploranium(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1from_1pcf(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::istream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::istream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::istream & is null"); + return 0; + } + result = (bool)(arg1)->load_from_pcf(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1from_1txt_1or_1csv(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::istream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::istream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::istream & is null"); + return 0; + } + result = (bool)(arg1)->load_from_txt_or_csv(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1from_1Gr135_1txt(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::istream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::istream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::istream & is null"); + return 0; + } + result = (bool)(arg1)->load_from_Gr135_txt(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1from_1spectroscopic_1daily_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::istream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::istream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::istream & is null"); + return 0; + } + result = (bool)(arg1)->load_from_spectroscopic_daily_file(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1from_1srpm210_1csv(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::istream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::istream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::istream & is null"); + return 0; + } + result = (bool)(arg1)->load_from_srpm210_csv(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1from_1D3S_1raw(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::istream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::istream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::istream & is null"); + return 0; + } + result = (bool)(arg1)->load_from_D3S_raw(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1from_1amptek_1mca(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::istream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::istream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::istream & is null"); + return 0; + } + result = (bool)(arg1)->load_from_amptek_mca(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1from_1ortec_1listmode(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::istream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::istream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::istream & is null"); + return 0; + } + result = (bool)(arg1)->load_from_ortec_listmode(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1from_1lsrm_1spe(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::istream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::istream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::istream & is null"); + return 0; + } + result = (bool)(arg1)->load_from_lsrm_spe(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1from_1tka(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::istream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::istream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::istream & is null"); + return 0; + } + result = (bool)(arg1)->load_from_tka(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1from_1multiact(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::istream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::istream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::istream & is null"); + return 0; + } + result = (bool)(arg1)->load_from_multiact(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1from_1phd(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::istream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::istream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::istream & is null"); + return 0; + } + result = (bool)(arg1)->load_from_phd(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1from_1lzs(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::istream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::istream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::istream & is null"); + return 0; + } + result = (bool)(arg1)->load_from_lzs(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1from_1radiacode(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::istream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::istream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::istream & is null"); + return 0; + } + result = (bool)(arg1)->load_from_radiacode(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1from_1radiacode_1spectrogram(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::istream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::istream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::istream & is null"); + return 0; + } + result = (bool)(arg1)->load_from_radiacode_spectrogram(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1from_1xml_1scan_1data(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::istream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::istream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::istream & is null"); + return 0; + } + result = (bool)(arg1)->load_from_xml_scan_data(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1from_1iaea(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::istream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::istream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::istream & is null"); + return 0; + } + result = (bool)(arg1)->load_from_iaea(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1from_1chn(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::istream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::istream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::istream & is null"); + return 0; + } + result = (bool)(arg1)->load_from_chn(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1from_1cnf(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::istream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::istream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::istream & is null"); + return 0; + } + result = (bool)(arg1)->load_from_cnf(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1from_1tracs_1mps(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::istream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::istream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::istream & is null"); + return 0; + } + result = (bool)(arg1)->load_from_tracs_mps(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1from_1aram(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::istream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::istream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::istream & is null"); + return 0; + } + result = (bool)(arg1)->load_from_aram(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1from_1json(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::istream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::istream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::istream & is null"); + return 0; + } + result = (bool)(arg1)->load_from_json(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1load_1from_1caen_1gxml(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::istream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::istream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::istream & is null"); + return 0; + } + result = (bool)(arg1)->load_from_caen_gxml(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1RebinToCommonBinning_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SpecUtils::SpecFile::CleanupAfterLoadFlags result; + + (void)jenv; + (void)jcls; + result = (SpecUtils::SpecFile::CleanupAfterLoadFlags)SpecUtils::SpecFile::RebinToCommonBinning; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1DontChangeOrReorderSamples_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SpecUtils::SpecFile::CleanupAfterLoadFlags result; + + (void)jenv; + (void)jcls; + result = (SpecUtils::SpecFile::CleanupAfterLoadFlags)SpecUtils::SpecFile::DontChangeOrReorderSamples; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1ReorderSamplesByTime_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SpecUtils::SpecFile::CleanupAfterLoadFlags result; + + (void)jenv; + (void)jcls; + result = (SpecUtils::SpecFile::CleanupAfterLoadFlags)SpecUtils::SpecFile::ReorderSamplesByTime; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1StandardCleanup_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + SpecUtils::SpecFile::CleanupAfterLoadFlags result; + + (void)jenv; + (void)jcls; + result = (SpecUtils::SpecFile::CleanupAfterLoadFlags)SpecUtils::SpecFile::StandardCleanup; + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1cleanup_1after_1load_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SpecUtils::SpecFile *arg1 = 0 ; + unsigned int arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = (unsigned int)jarg2; + (arg1)->cleanup_after_load(arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1cleanup_1after_1load_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + SpecUtils::SpecFile *arg1 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + (arg1)->cleanup_after_load(); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1recalc_1total_1counts(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + SpecUtils::SpecFile *arg1 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + (arg1)->recalc_total_counts(); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1merge_1neutron_1meas_1into_1gamma_1meas(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + SpecUtils::SpecFile *arg1 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + (arg1)->merge_neutron_meas_into_gamma_meas(); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1rebin_1measurement(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jobject jarg3_) { + SpecUtils::SpecFile *arg1 = 0 ; + std::shared_ptr< SpecUtils::EnergyCalibration const > *arg2 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *arg3 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > tempnull3 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg3_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::shared_ptr< SpecUtils::EnergyCalibration const > **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::shared_ptr< SpecUtils::EnergyCalibration const > const & is null"); + return ; + } + arg3 = jarg3 ? *(std::shared_ptr< SpecUtils::Measurement const > **)&jarg3 : &tempnull3; + (arg1)->rebin_measurement((std::shared_ptr< SpecUtils::EnergyCalibration const > const &)*arg2,(std::shared_ptr< SpecUtils::Measurement const > const &)*arg3); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1rebin_1all_1measurements(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SpecUtils::SpecFile *arg1 = 0 ; + std::shared_ptr< SpecUtils::EnergyCalibration const > *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::shared_ptr< SpecUtils::EnergyCalibration const > **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::shared_ptr< SpecUtils::EnergyCalibration const > const & is null"); + return ; + } + (arg1)->rebin_all_measurements((std::shared_ptr< SpecUtils::EnergyCalibration const > const &)*arg2); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1set_1energy_1calibration_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jobject jarg3_) { + SpecUtils::SpecFile *arg1 = 0 ; + std::shared_ptr< SpecUtils::EnergyCalibration const > *arg2 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > *arg3 = 0 ; + std::shared_ptr< SpecUtils::Measurement const > tempnull3 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg3_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::shared_ptr< SpecUtils::EnergyCalibration const > **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::shared_ptr< SpecUtils::EnergyCalibration const > const & is null"); + return ; + } + arg3 = jarg3 ? *(std::shared_ptr< SpecUtils::Measurement const > **)&jarg3 : &tempnull3; + (arg1)->set_energy_calibration((std::shared_ptr< SpecUtils::EnergyCalibration const > const &)*arg2,(std::shared_ptr< SpecUtils::Measurement const > const &)*arg3); +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1set_1energy_1calibration_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jobject jarg4_) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::shared_ptr< SpecUtils::EnergyCalibration const > *arg2 = 0 ; + std::set< int > arg3 ; + std::vector< std::string > arg4 ; + std::set< int > *argp3 ; + std::vector< std::string > *argp4 ; + size_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg4_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::shared_ptr< SpecUtils::EnergyCalibration const > **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::shared_ptr< SpecUtils::EnergyCalibration const > const & is null"); + return 0; + } + argp3 = *(std::set< int > **)&jarg3; + if (!argp3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::set< int >"); + return 0; + } + arg3 = *argp3; + argp4 = *(std::vector< std::string > **)&jarg4; + if (!argp4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< std::string >"); + return 0; + } + arg4 = *argp4; + result = (arg1)->set_energy_calibration((std::shared_ptr< SpecUtils::EnergyCalibration const > const &)*arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4)); + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1set_1energy_1calibration_1from_1CALp_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SpecUtils::SpecFile *arg1 = 0 ; + std::istream *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::istream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::istream & is null"); + return ; + } + (arg1)->set_energy_calibration_from_CALp_file(*arg2); +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1detector_1names_1to_1numbers(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::vector< std::string > *arg2 = 0 ; + std::set< int > result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::vector< std::string > **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::string > const & is null"); + return 0; + } + result = ((SpecUtils::SpecFile const *)arg1)->detector_names_to_numbers((std::vector< std::string > const &)*arg2); + *(std::set< int > **)&jresult = new std::set< int >(result); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1write_1to_1file_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3) { + SpecUtils::SpecFile *arg1 = 0 ; + std::string arg2 ; + SpecUtils::SaveSpectrumAsType arg3 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + (&arg2)->assign(arg2_pstr); + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + arg3 = (SpecUtils::SaveSpectrumAsType)jarg3; + ((SpecUtils::SpecFile const *)arg1)->write_to_file(SWIG_STD_MOVE(arg2),arg3); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1write_1to_1file_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jlong jarg4, jint jarg5) { + SpecUtils::SpecFile *arg1 = 0 ; + std::string arg2 ; + std::set< int > arg3 ; + std::set< int > arg4 ; + SpecUtils::SaveSpectrumAsType arg5 ; + std::set< int > const *argp3 ; + std::set< int > const *argp4 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + (&arg2)->assign(arg2_pstr); + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + argp3 = *(std::set< int > **)&jarg3; + if (!argp3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::set< int > const"); + return ; + } + arg3 = *argp3; + argp4 = *(std::set< int > **)&jarg4; + if (!argp4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::set< int > const"); + return ; + } + arg4 = *argp4; + arg5 = (SpecUtils::SaveSpectrumAsType)jarg5; + ((SpecUtils::SpecFile const *)arg1)->write_to_file(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),arg5); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1write_1to_1file_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_, jint jarg5) { + SpecUtils::SpecFile *arg1 = 0 ; + std::string arg2 ; + std::vector< int > arg3 ; + std::vector< int > arg4 ; + SpecUtils::SaveSpectrumAsType arg5 ; + std::vector< int > const *argp3 ; + std::vector< int > const *argp4 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg3_; + (void)jarg4_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + (&arg2)->assign(arg2_pstr); + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + argp3 = *(std::vector< int > **)&jarg3; + if (!argp3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< int > const"); + return ; + } + arg3 = *argp3; + argp4 = *(std::vector< int > **)&jarg4; + if (!argp4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< int > const"); + return ; + } + arg4 = *argp4; + arg5 = (SpecUtils::SaveSpectrumAsType)jarg5; + ((SpecUtils::SpecFile const *)arg1)->write_to_file(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),arg5); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1write_1to_1file_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jlong jarg4, jobject jarg4_, jint jarg5) { + SpecUtils::SpecFile *arg1 = 0 ; + std::string *arg2 = 0 ; + std::set< int > *arg3 = 0 ; + std::vector< std::string > *arg4 = 0 ; + SpecUtils::SaveSpectrumAsType arg5 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg4_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + arg3 = *(std::set< int > **)&jarg3; + if (!arg3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::set< int > const & is null"); + return ; + } + arg4 = *(std::vector< std::string > **)&jarg4; + if (!arg4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::string > const & is null"); + return ; + } + arg5 = (SpecUtils::SaveSpectrumAsType)jarg5; + ((SpecUtils::SpecFile const *)arg1)->write_to_file((std::string const &)*arg2,(std::set< int > const &)*arg3,(std::vector< std::string > const &)*arg4,arg5); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1write_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jint jarg5) { + SpecUtils::SpecFile *arg1 = 0 ; + std::ostream *arg2 = 0 ; + std::set< int > arg3 ; + std::set< int > arg4 ; + SpecUtils::SaveSpectrumAsType arg5 ; + std::set< int > *argp3 ; + std::set< int > const *argp4 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::ostream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::ostream & is null"); + return ; + } + argp3 = *(std::set< int > **)&jarg3; + if (!argp3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::set< int >"); + return ; + } + arg3 = *argp3; + argp4 = *(std::set< int > **)&jarg4; + if (!argp4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::set< int > const"); + return ; + } + arg4 = *argp4; + arg5 = (SpecUtils::SaveSpectrumAsType)jarg5; + ((SpecUtils::SpecFile const *)arg1)->write(*arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),arg5); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1write_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jobject jarg4_, jint jarg5) { + SpecUtils::SpecFile *arg1 = 0 ; + std::ostream *arg2 = 0 ; + std::set< int > arg3 ; + std::vector< std::string > *arg4 = 0 ; + SpecUtils::SaveSpectrumAsType arg5 ; + std::set< int > *argp3 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg4_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::ostream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::ostream & is null"); + return ; + } + argp3 = *(std::set< int > **)&jarg3; + if (!argp3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::set< int >"); + return ; + } + arg3 = *argp3; + arg4 = *(std::vector< std::string > **)&jarg4; + if (!arg4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::string > const & is null"); + return ; + } + arg5 = (SpecUtils::SaveSpectrumAsType)jarg5; + ((SpecUtils::SpecFile const *)arg1)->write(*arg2,SWIG_STD_MOVE(arg3),(std::vector< std::string > const &)*arg4,arg5); +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1write_1pcf(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::ostream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::ostream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::ostream & is null"); + return 0; + } + result = (bool)((SpecUtils::SpecFile const *)arg1)->write_pcf(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1write_12006_1N42(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::ostream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::ostream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::ostream & is null"); + return 0; + } + result = (bool)((SpecUtils::SpecFile const *)arg1)->write_2006_N42(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1write_1csv(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::ostream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::ostream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::ostream & is null"); + return 0; + } + result = (bool)((SpecUtils::SpecFile const *)arg1)->write_csv(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1write_1txt(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::ostream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::ostream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::ostream & is null"); + return 0; + } + result = (bool)((SpecUtils::SpecFile const *)arg1)->write_txt(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1write_1integer_1chn_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::ostream *arg2 = 0 ; + std::set< int > arg3 ; + std::set< int > *arg4 = 0 ; + std::set< int > *argp3 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::ostream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::ostream & is null"); + return 0; + } + argp3 = *(std::set< int > **)&jarg3; + if (!argp3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::set< int >"); + return 0; + } + arg3 = *argp3; + arg4 = *(std::set< int > **)&jarg4; + if (!arg4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::set< int > const & is null"); + return 0; + } + result = (bool)((SpecUtils::SpecFile const *)arg1)->write_integer_chn(*arg2,SWIG_STD_MOVE(arg3),(std::set< int > const &)*arg4); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1write_1integer_1chn_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jobject jarg4_) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::ostream *arg2 = 0 ; + std::set< int > arg3 ; + std::vector< std::string > *arg4 = 0 ; + std::set< int > *argp3 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg4_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::ostream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::ostream & is null"); + return 0; + } + argp3 = *(std::set< int > **)&jarg3; + if (!argp3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::set< int >"); + return 0; + } + arg3 = *argp3; + arg4 = *(std::vector< std::string > **)&jarg4; + if (!arg4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::string > const & is null"); + return 0; + } + result = (bool)((SpecUtils::SpecFile const *)arg1)->write_integer_chn(*arg2,SWIG_STD_MOVE(arg3),(std::vector< std::string > const &)*arg4); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1write_1binary_1spc(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jint jarg3, jlong jarg4, jlong jarg5) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::ostream *arg2 = 0 ; + SpecUtils::SpecFile::SpcBinaryType arg3 ; + std::set< int > arg4 ; + std::set< int > *arg5 = 0 ; + std::set< int > *argp4 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::ostream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::ostream & is null"); + return 0; + } + arg3 = (SpecUtils::SpecFile::SpcBinaryType)jarg3; + argp4 = *(std::set< int > **)&jarg4; + if (!argp4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::set< int >"); + return 0; + } + arg4 = *argp4; + arg5 = *(std::set< int > **)&jarg5; + if (!arg5) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::set< int > const & is null"); + return 0; + } + result = (bool)((SpecUtils::SpecFile const *)arg1)->write_binary_spc(*arg2,arg3,SWIG_STD_MOVE(arg4),(std::set< int > const &)*arg5); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1write_1ascii_1spc(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::ostream *arg2 = 0 ; + std::set< int > arg3 ; + std::set< int > *arg4 = 0 ; + std::set< int > *argp3 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::ostream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::ostream & is null"); + return 0; + } + argp3 = *(std::set< int > **)&jarg3; + if (!argp3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::set< int >"); + return 0; + } + arg3 = *argp3; + arg4 = *(std::set< int > **)&jarg4; + if (!arg4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::set< int > const & is null"); + return 0; + } + result = (bool)((SpecUtils::SpecFile const *)arg1)->write_ascii_spc(*arg2,SWIG_STD_MOVE(arg3),(std::set< int > const &)*arg4); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1write_1binary_1exploranium_1gr130v0(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::ostream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::ostream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::ostream & is null"); + return 0; + } + result = (bool)((SpecUtils::SpecFile const *)arg1)->write_binary_exploranium_gr130v0(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1write_1binary_1exploranium_1gr135v2(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::ostream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::ostream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::ostream & is null"); + return 0; + } + result = (bool)((SpecUtils::SpecFile const *)arg1)->write_binary_exploranium_gr135v2(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1write_1iaea_1spe(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::ostream *arg2 = 0 ; + std::set< int > arg3 ; + std::set< int > *arg4 = 0 ; + std::set< int > *argp3 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::ostream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::ostream & is null"); + return 0; + } + argp3 = *(std::set< int > **)&jarg3; + if (!argp3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::set< int >"); + return 0; + } + arg3 = *argp3; + arg4 = *(std::set< int > **)&jarg4; + if (!arg4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::set< int > const & is null"); + return 0; + } + result = (bool)((SpecUtils::SpecFile const *)arg1)->write_iaea_spe(*arg2,SWIG_STD_MOVE(arg3),(std::set< int > const &)*arg4); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1write_1cnf(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::ostream *arg2 = 0 ; + std::set< int > arg3 ; + std::set< int > *arg4 = 0 ; + std::set< int > *argp3 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::ostream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::ostream & is null"); + return 0; + } + argp3 = *(std::set< int > **)&jarg3; + if (!argp3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::set< int >"); + return 0; + } + arg3 = *argp3; + arg4 = *(std::set< int > **)&jarg4; + if (!arg4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::set< int > const & is null"); + return 0; + } + result = (bool)((SpecUtils::SpecFile const *)arg1)->write_cnf(*arg2,SWIG_STD_MOVE(arg3),(std::set< int > const &)*arg4); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1write_1tka(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::ostream *arg2 = 0 ; + std::set< int > arg3 ; + std::set< int > *arg4 = 0 ; + std::set< int > *argp3 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::ostream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::ostream & is null"); + return 0; + } + argp3 = *(std::set< int > **)&jarg3; + if (!argp3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::set< int >"); + return 0; + } + arg3 = *argp3; + arg4 = *(std::set< int > **)&jarg4; + if (!arg4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::set< int > const & is null"); + return 0; + } + result = (bool)((SpecUtils::SpecFile const *)arg1)->write_tka(*arg2,SWIG_STD_MOVE(arg3),(std::set< int > const &)*arg4); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1write_1d3_1html(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jobject jarg3_, jlong jarg4, jlong jarg5, jobject jarg5_) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::ostream *arg2 = 0 ; + D3SpectrumExport::D3SpectrumChartOptions *arg3 = 0 ; + std::set< int > arg4 ; + std::vector< std::string > arg5 ; + std::set< int > *argp4 ; + std::vector< std::string > *argp5 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg3_; + (void)jarg5_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::ostream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::ostream & is null"); + return 0; + } + arg3 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg3; + if (!arg3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "D3SpectrumExport::D3SpectrumChartOptions const & is null"); + return 0; + } + argp4 = *(std::set< int > **)&jarg4; + if (!argp4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::set< int >"); + return 0; + } + arg4 = *argp4; + argp5 = *(std::vector< std::string > **)&jarg5; + if (!argp5) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< std::string >"); + return 0; + } + arg5 = *argp5; + result = (bool)((SpecUtils::SpecFile const *)arg1)->write_d3_html(*arg2,(D3SpectrumExport::D3SpectrumChartOptions const &)*arg3,SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5)); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_12012N42_1VERSION_1get(JNIEnv *jenv, jclass jcls) { + jint jresult = 0 ; + int result; + + (void)jenv; + (void)jcls; + result = (int)(5); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1create_12012_1N42_1xml(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + SwigValueWrapper< std::shared_ptr< ::rapidxml::xml_document< char > > > result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = ((SpecUtils::SpecFile const *)arg1)->create_2012_N42_xml(); + *(std::shared_ptr< ::rapidxml::xml_document< char > > **)&jresult = new std::shared_ptr< ::rapidxml::xml_document< char > >(result); + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1write_12012_1N42(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jboolean jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::ostream *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + arg2 = *(std::ostream **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::ostream & is null"); + return 0; + } + result = (bool)((SpecUtils::SpecFile const *)arg1)->write_2012_N42(*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SpecFile_1mutex(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::SpecFile *arg1 = 0 ; + std::recursive_mutex *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::SpecFile **)&jarg1; + result = (std::recursive_mutex *) &((SpecUtils::SpecFile const *)arg1)->mutex(); + *(std::recursive_mutex **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysisResult_1remark_1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + SpecUtils::DetectorAnalysisResult *arg1 = 0 ; + std::string *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysisResult **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + if (arg1) (arg1)->remark_ = *arg2; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysisResult_1remark_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + SpecUtils::DetectorAnalysisResult *arg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysisResult **)&jarg1; + result = (std::string *) & ((arg1)->remark_); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysisResult_1nuclide_1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + SpecUtils::DetectorAnalysisResult *arg1 = 0 ; + std::string *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysisResult **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + if (arg1) (arg1)->nuclide_ = *arg2; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysisResult_1nuclide_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + SpecUtils::DetectorAnalysisResult *arg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysisResult **)&jarg1; + result = (std::string *) & ((arg1)->nuclide_); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysisResult_1activity_1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { + SpecUtils::DetectorAnalysisResult *arg1 = 0 ; + float arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysisResult **)&jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->activity_ = arg2; +} + + +SWIGEXPORT jfloat JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysisResult_1activity_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jfloat jresult = 0 ; + SpecUtils::DetectorAnalysisResult *arg1 = 0 ; + float result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysisResult **)&jarg1; + result = (float) ((arg1)->activity_); + jresult = (jfloat)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysisResult_1nuclide_1type_1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + SpecUtils::DetectorAnalysisResult *arg1 = 0 ; + std::string *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysisResult **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + if (arg1) (arg1)->nuclide_type_ = *arg2; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysisResult_1nuclide_1type_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + SpecUtils::DetectorAnalysisResult *arg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysisResult **)&jarg1; + result = (std::string *) & ((arg1)->nuclide_type_); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysisResult_1id_1confidence_1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + SpecUtils::DetectorAnalysisResult *arg1 = 0 ; + std::string *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysisResult **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + if (arg1) (arg1)->id_confidence_ = *arg2; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysisResult_1id_1confidence_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + SpecUtils::DetectorAnalysisResult *arg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysisResult **)&jarg1; + result = (std::string *) & ((arg1)->id_confidence_); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysisResult_1distance_1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { + SpecUtils::DetectorAnalysisResult *arg1 = 0 ; + float arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysisResult **)&jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->distance_ = arg2; +} + + +SWIGEXPORT jfloat JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysisResult_1distance_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jfloat jresult = 0 ; + SpecUtils::DetectorAnalysisResult *arg1 = 0 ; + float result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysisResult **)&jarg1; + result = (float) ((arg1)->distance_); + jresult = (jfloat)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysisResult_1dose_1rate_1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { + SpecUtils::DetectorAnalysisResult *arg1 = 0 ; + float arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysisResult **)&jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->dose_rate_ = arg2; +} + + +SWIGEXPORT jfloat JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysisResult_1dose_1rate_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jfloat jresult = 0 ; + SpecUtils::DetectorAnalysisResult *arg1 = 0 ; + float result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysisResult **)&jarg1; + result = (float) ((arg1)->dose_rate_); + jresult = (jfloat)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysisResult_1real_1time_1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { + SpecUtils::DetectorAnalysisResult *arg1 = 0 ; + float arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysisResult **)&jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->real_time_ = arg2; +} + + +SWIGEXPORT jfloat JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysisResult_1real_1time_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jfloat jresult = 0 ; + SpecUtils::DetectorAnalysisResult *arg1 = 0 ; + float result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysisResult **)&jarg1; + result = (float) ((arg1)->real_time_); + jresult = (jfloat)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysisResult_1detector_1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + SpecUtils::DetectorAnalysisResult *arg1 = 0 ; + std::string *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysisResult **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + if (arg1) (arg1)->detector_ = *arg2; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysisResult_1detector_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + SpecUtils::DetectorAnalysisResult *arg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysisResult **)&jarg1; + result = (std::string *) & ((arg1)->detector_); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_new_1DetectorAnalysisResult(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + SpecUtils::DetectorAnalysisResult *result = 0 ; + + (void)jenv; + (void)jcls; + result = (SpecUtils::DetectorAnalysisResult *)new SpecUtils::DetectorAnalysisResult(); + *(SpecUtils::DetectorAnalysisResult **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysisResult_1reset(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + SpecUtils::DetectorAnalysisResult *arg1 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysisResult **)&jarg1; + (arg1)->reset(); +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysisResult_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + SpecUtils::DetectorAnalysisResult *arg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysisResult **)&jarg1; + result = (bool)((SpecUtils::DetectorAnalysisResult const *)arg1)->isEmpty(); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_delete_1DetectorAnalysisResult(JNIEnv *jenv, jclass jcls, jlong jarg1) { + SpecUtils::DetectorAnalysisResult *arg1 = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SpecUtils::DetectorAnalysisResult **)&jarg1; + delete arg1; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysis_1remarks_1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) { + SpecUtils::DetectorAnalysis *arg1 = 0 ; + std::vector< std::string > *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + arg1 = *(SpecUtils::DetectorAnalysis **)&jarg1; + arg2 = *(std::vector< std::string > **)&jarg2; + if (arg1) (arg1)->remarks_ = *arg2; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysis_1remarks_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::DetectorAnalysis *arg1 = 0 ; + std::vector< std::string > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysis **)&jarg1; + result = (std::vector< std::string > *)& ((arg1)->remarks_); + *(std::vector< std::string > **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysis_1algorithm_1name_1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + SpecUtils::DetectorAnalysis *arg1 = 0 ; + std::string *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysis **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + if (arg1) (arg1)->algorithm_name_ = *arg2; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysis_1algorithm_1name_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + SpecUtils::DetectorAnalysis *arg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysis **)&jarg1; + result = (std::string *) & ((arg1)->algorithm_name_); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysis_1algorithm_1component_1versions_1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SpecUtils::DetectorAnalysis *arg1 = 0 ; + std::vector< std::pair< std::string,std::string > > *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysis **)&jarg1; + arg2 = *(std::vector< std::pair< std::string,std::string > > **)&jarg2; + if (arg1) (arg1)->algorithm_component_versions_ = *arg2; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysis_1algorithm_1component_1versions_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::DetectorAnalysis *arg1 = 0 ; + std::vector< std::pair< std::string,std::string > > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysis **)&jarg1; + result = (std::vector< std::pair< std::string,std::string > > *)& ((arg1)->algorithm_component_versions_); + *(std::vector< std::pair< std::string,std::string > > **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysis_1algorithm_1creator_1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + SpecUtils::DetectorAnalysis *arg1 = 0 ; + std::string *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysis **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + if (arg1) (arg1)->algorithm_creator_ = *arg2; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysis_1algorithm_1creator_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + SpecUtils::DetectorAnalysis *arg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysis **)&jarg1; + result = (std::string *) & ((arg1)->algorithm_creator_); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysis_1algorithm_1description_1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + SpecUtils::DetectorAnalysis *arg1 = 0 ; + std::string *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysis **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + if (arg1) (arg1)->algorithm_description_ = *arg2; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysis_1algorithm_1description_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + SpecUtils::DetectorAnalysis *arg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysis **)&jarg1; + result = (std::string *) & ((arg1)->algorithm_description_); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysis_1analysis_1start_1time_1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SpecUtils::DetectorAnalysis *arg1 = 0 ; + SpecUtils::time_point_t arg2 ; + SpecUtils::time_point_t *argp2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysis **)&jarg1; + argp2 = *(SpecUtils::time_point_t **)&jarg2; + if (!argp2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null SpecUtils::time_point_t"); + return ; + } + arg2 = *argp2; + if (arg1) (arg1)->analysis_start_time_ = arg2; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysis_1analysis_1start_1time_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::DetectorAnalysis *arg1 = 0 ; + SpecUtils::time_point_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysis **)&jarg1; + result = ((arg1)->analysis_start_time_); + *(SpecUtils::time_point_t **)&jresult = new SpecUtils::time_point_t(result); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysis_1analysis_1computation_1duration_1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { + SpecUtils::DetectorAnalysis *arg1 = 0 ; + float arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysis **)&jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->analysis_computation_duration_ = arg2; +} + + +SWIGEXPORT jfloat JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysis_1analysis_1computation_1duration_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jfloat jresult = 0 ; + SpecUtils::DetectorAnalysis *arg1 = 0 ; + float result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysis **)&jarg1; + result = (float) ((arg1)->analysis_computation_duration_); + jresult = (jfloat)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysis_1algorithm_1result_1description_1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + SpecUtils::DetectorAnalysis *arg1 = 0 ; + std::string *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysis **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + if (arg1) (arg1)->algorithm_result_description_ = *arg2; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysis_1algorithm_1result_1description_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + SpecUtils::DetectorAnalysis *arg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysis **)&jarg1; + result = (std::string *) & ((arg1)->algorithm_result_description_); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysis_1results_1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SpecUtils::DetectorAnalysis *arg1 = 0 ; + std::vector< SpecUtils::DetectorAnalysisResult > *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysis **)&jarg1; + arg2 = *(std::vector< SpecUtils::DetectorAnalysisResult > **)&jarg2; + if (arg1) (arg1)->results_ = *arg2; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysis_1results_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::DetectorAnalysis *arg1 = 0 ; + std::vector< SpecUtils::DetectorAnalysisResult > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysis **)&jarg1; + result = (std::vector< SpecUtils::DetectorAnalysisResult > *)& ((arg1)->results_); + *(std::vector< SpecUtils::DetectorAnalysisResult > **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_new_1DetectorAnalysis(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + SpecUtils::DetectorAnalysis *result = 0 ; + + (void)jenv; + (void)jcls; + result = (SpecUtils::DetectorAnalysis *)new SpecUtils::DetectorAnalysis(); + *(SpecUtils::DetectorAnalysis **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysis_1reset(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + SpecUtils::DetectorAnalysis *arg1 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysis **)&jarg1; + (arg1)->reset(); +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_DetectorAnalysis_1is_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + SpecUtils::DetectorAnalysis *arg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::DetectorAnalysis **)&jarg1; + result = (bool)((SpecUtils::DetectorAnalysis const *)arg1)->is_empty(); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_delete_1DetectorAnalysis(JNIEnv *jenv, jclass jcls, jlong jarg1) { + SpecUtils::DetectorAnalysis *arg1 = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SpecUtils::DetectorAnalysis **)&jarg1; + delete arg1; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_MultimediaData_1remark_1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + SpecUtils::MultimediaData *arg1 = 0 ; + std::string *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::MultimediaData **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + if (arg1) (arg1)->remark_ = *arg2; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_MultimediaData_1remark_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + SpecUtils::MultimediaData *arg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::MultimediaData **)&jarg1; + result = (std::string *) & ((arg1)->remark_); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_MultimediaData_1descriptions_1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + SpecUtils::MultimediaData *arg1 = 0 ; + std::string *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::MultimediaData **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + if (arg1) (arg1)->descriptions_ = *arg2; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_MultimediaData_1descriptions_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + SpecUtils::MultimediaData *arg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::MultimediaData **)&jarg1; + result = (std::string *) & ((arg1)->descriptions_); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_MultimediaData_1data_1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SpecUtils::MultimediaData *arg1 = 0 ; + std::vector< char > *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::MultimediaData **)&jarg1; + arg2 = *(std::vector< char > **)&jarg2; + if (arg1) (arg1)->data_ = *arg2; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_MultimediaData_1data_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::MultimediaData *arg1 = 0 ; + std::vector< char > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::MultimediaData **)&jarg1; + result = (std::vector< char > *)& ((arg1)->data_); + *(std::vector< char > **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_MultimediaData_1data_1encoding_1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + SpecUtils::MultimediaData *arg1 = 0 ; + SpecUtils::MultimediaData::EncodingType arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::MultimediaData **)&jarg1; + arg2 = (SpecUtils::MultimediaData::EncodingType)jarg2; + if (arg1) (arg1)->data_encoding_ = arg2; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_MultimediaData_1data_1encoding_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + SpecUtils::MultimediaData *arg1 = 0 ; + SpecUtils::MultimediaData::EncodingType result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::MultimediaData **)&jarg1; + result = (SpecUtils::MultimediaData::EncodingType) ((arg1)->data_encoding_); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_MultimediaData_1capture_1start_1time_1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + SpecUtils::MultimediaData *arg1 = 0 ; + SpecUtils::time_point_t arg2 ; + SpecUtils::time_point_t *argp2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::MultimediaData **)&jarg1; + argp2 = *(SpecUtils::time_point_t **)&jarg2; + if (!argp2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null SpecUtils::time_point_t"); + return ; + } + arg2 = *argp2; + if (arg1) (arg1)->capture_start_time_ = arg2; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_MultimediaData_1capture_1start_1time_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::MultimediaData *arg1 = 0 ; + SpecUtils::time_point_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::MultimediaData **)&jarg1; + result = ((arg1)->capture_start_time_); + *(SpecUtils::time_point_t **)&jresult = new SpecUtils::time_point_t(result); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_MultimediaData_1file_1uri_1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + SpecUtils::MultimediaData *arg1 = 0 ; + std::string *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::MultimediaData **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + if (arg1) (arg1)->file_uri_ = *arg2; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_MultimediaData_1file_1uri_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + SpecUtils::MultimediaData *arg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::MultimediaData **)&jarg1; + result = (std::string *) & ((arg1)->file_uri_); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_MultimediaData_1mime_1type_1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + SpecUtils::MultimediaData *arg1 = 0 ; + std::string *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::MultimediaData **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + if (arg1) (arg1)->mime_type_ = *arg2; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_MultimediaData_1mime_1type_1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + SpecUtils::MultimediaData *arg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::MultimediaData **)&jarg1; + result = (std::string *) & ((arg1)->mime_type_); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_new_1MultimediaData(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + SpecUtils::MultimediaData *result = 0 ; + + (void)jenv; + (void)jcls; + result = (SpecUtils::MultimediaData *)new SpecUtils::MultimediaData(); + *(SpecUtils::MultimediaData **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_delete_1MultimediaData(JNIEnv *jenv, jclass jcls, jlong jarg1) { + SpecUtils::MultimediaData *arg1 = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SpecUtils::MultimediaData **)&jarg1; + delete arg1; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_EnergyCalibration_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + SpecUtils::EnergyCalibration *arg1 = 0 ; + SpecUtils::EnergyCalType result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::EnergyCalibration **)&jarg1; + result = (SpecUtils::EnergyCalType)((SpecUtils::EnergyCalibration const *)arg1)->type(); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_EnergyCalibration_1valid(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + SpecUtils::EnergyCalibration *arg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::EnergyCalibration **)&jarg1; + result = (bool)((SpecUtils::EnergyCalibration const *)arg1)->valid(); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_EnergyCalibration_1coefficients(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::EnergyCalibration *arg1 = 0 ; + std::vector< float > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::EnergyCalibration **)&jarg1; + result = (std::vector< float > *) &((SpecUtils::EnergyCalibration const *)arg1)->coefficients(); + *(std::shared_ptr< const std::vector > **)&jresult = new std::shared_ptr< const std::vector >(result SWIG_NO_NULL_DELETER_0); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_EnergyCalibration_1deviation_1pairs(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::EnergyCalibration *arg1 = 0 ; + std::vector< std::pair< float,float > > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::EnergyCalibration **)&jarg1; + result = (std::vector< std::pair< float,float > > *) &((SpecUtils::EnergyCalibration const *)arg1)->deviation_pairs(); + *(std::vector< std::pair< float,float > > **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_EnergyCalibration_1channel_1energies(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::EnergyCalibration *arg1 = 0 ; + std::shared_ptr< std::vector< float > const > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::EnergyCalibration **)&jarg1; + result = (std::shared_ptr< std::vector< float > const > *) &((SpecUtils::EnergyCalibration const *)arg1)->channel_energies(); + *(std::shared_ptr< std::vector< float > const > **)&jresult = *result ? new std::shared_ptr< std::vector< float > const >(*result) : 0; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_EnergyCalibration_1num_1channels(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::EnergyCalibration *arg1 = 0 ; + size_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::EnergyCalibration **)&jarg1; + result = ((SpecUtils::EnergyCalibration const *)arg1)->num_channels(); + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_new_1EnergyCalibration(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + SpecUtils::EnergyCalibration *result = 0 ; + + (void)jenv; + (void)jcls; + result = (SpecUtils::EnergyCalibration *)new SpecUtils::EnergyCalibration(); + *(SpecUtils::EnergyCalibration **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_EnergyCalibration_1set_1polynomial(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jobject jarg3_, jlong jarg4) { + SpecUtils::EnergyCalibration *arg1 = 0 ; + size_t arg2 ; + std::vector< float > *arg3 = 0 ; + std::vector< std::pair< float,float > > *arg4 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg3_; + arg1 = *(SpecUtils::EnergyCalibration **)&jarg1; + arg2 = (size_t)jarg2; + + arg3 = (std::vector< float > *)((*(std::shared_ptr< const std::vector > **)&jarg3) ? (*(std::shared_ptr< const std::vector > **)&jarg3)->get() : 0); + if (!arg3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< float > const & reference is null"); + return ; + } + arg4 = *(std::vector< std::pair< float,float > > **)&jarg4; + if (!arg4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< float,float > > const & is null"); + return ; + } + (arg1)->set_polynomial(SWIG_STD_MOVE(arg2),(std::vector< float > const &)*arg3,(std::vector< std::pair< float,float > > const &)*arg4); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_EnergyCalibration_1set_1default_1polynomial(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jobject jarg3_, jlong jarg4) { + SpecUtils::EnergyCalibration *arg1 = 0 ; + size_t arg2 ; + std::vector< float > *arg3 = 0 ; + std::vector< std::pair< float,float > > *arg4 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg3_; + arg1 = *(SpecUtils::EnergyCalibration **)&jarg1; + arg2 = (size_t)jarg2; + + arg3 = (std::vector< float > *)((*(std::shared_ptr< const std::vector > **)&jarg3) ? (*(std::shared_ptr< const std::vector > **)&jarg3)->get() : 0); + if (!arg3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< float > const & reference is null"); + return ; + } + arg4 = *(std::vector< std::pair< float,float > > **)&jarg4; + if (!arg4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< float,float > > const & is null"); + return ; + } + (arg1)->set_default_polynomial(SWIG_STD_MOVE(arg2),(std::vector< float > const &)*arg3,(std::vector< std::pair< float,float > > const &)*arg4); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_EnergyCalibration_1set_1full_1range_1fraction(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jobject jarg3_, jlong jarg4) { + SpecUtils::EnergyCalibration *arg1 = 0 ; + size_t arg2 ; + std::vector< float > *arg3 = 0 ; + std::vector< std::pair< float,float > > *arg4 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg3_; + arg1 = *(SpecUtils::EnergyCalibration **)&jarg1; + arg2 = (size_t)jarg2; + + arg3 = (std::vector< float > *)((*(std::shared_ptr< const std::vector > **)&jarg3) ? (*(std::shared_ptr< const std::vector > **)&jarg3)->get() : 0); + if (!arg3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< float > const & reference is null"); + return ; + } + arg4 = *(std::vector< std::pair< float,float > > **)&jarg4; + if (!arg4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< float,float > > const & is null"); + return ; + } + (arg1)->set_full_range_fraction(SWIG_STD_MOVE(arg2),(std::vector< float > const &)*arg3,(std::vector< std::pair< float,float > > const &)*arg4); +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_EnergyCalibration_1set_1lower_1channel_1energy_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jobject jarg3_) { + SpecUtils::EnergyCalibration *arg1 = 0 ; + size_t arg2 ; + std::vector< float > *arg3 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg3_; + arg1 = *(SpecUtils::EnergyCalibration **)&jarg1; + arg2 = (size_t)jarg2; + + arg3 = (std::vector< float > *)((*(std::shared_ptr< const std::vector > **)&jarg3) ? (*(std::shared_ptr< const std::vector > **)&jarg3)->get() : 0); + if (!arg3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< float > const & reference is null"); + return ; + } + (arg1)->set_lower_channel_energy(SWIG_STD_MOVE(arg2),(std::vector< float > const &)*arg3); +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_EnergyCalibration_1memmorysize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + SpecUtils::EnergyCalibration *arg1 = 0 ; + size_t result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::EnergyCalibration **)&jarg1; + result = ((SpecUtils::EnergyCalibration const *)arg1)->memmorysize(); + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_EnergyCalibration_1channel_1for_1energy(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) { + jdouble jresult = 0 ; + SpecUtils::EnergyCalibration *arg1 = 0 ; + double arg2 ; + double result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::EnergyCalibration **)&jarg1; + arg2 = (double)jarg2; + result = (double)((SpecUtils::EnergyCalibration const *)arg1)->channel_for_energy(arg2); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_EnergyCalibration_1energy_1for_1channel(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) { + jdouble jresult = 0 ; + SpecUtils::EnergyCalibration *arg1 = 0 ; + double arg2 ; + double result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::EnergyCalibration **)&jarg1; + arg2 = (double)jarg2; + result = (double)((SpecUtils::EnergyCalibration const *)arg1)->energy_for_channel(arg2); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jfloat JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_EnergyCalibration_1lower_1energy(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jfloat jresult = 0 ; + SpecUtils::EnergyCalibration *arg1 = 0 ; + float result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::EnergyCalibration **)&jarg1; + result = (float)((SpecUtils::EnergyCalibration const *)arg1)->lower_energy(); + jresult = (jfloat)result; + return jresult; +} + + +SWIGEXPORT jfloat JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_EnergyCalibration_1upper_1energy(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jfloat jresult = 0 ; + SpecUtils::EnergyCalibration *arg1 = 0 ; + float result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::EnergyCalibration **)&jarg1; + result = (float)((SpecUtils::EnergyCalibration const *)arg1)->upper_energy(); + jresult = (jfloat)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_EnergyCalibration_1sm_1min_1channels_1get(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + size_t result; + + (void)jenv; + (void)jcls; + result = (size_t)SpecUtils::EnergyCalibration::sm_min_channels; + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_EnergyCalibration_1sm_1max_1channels_1get(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + size_t result; + + (void)jenv; + (void)jcls; + result = (size_t)SpecUtils::EnergyCalibration::sm_max_channels; + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT jfloat JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_EnergyCalibration_1sm_1polynomial_1offset_1limit_1get(JNIEnv *jenv, jclass jcls) { + jfloat jresult = 0 ; + float result; + + (void)jenv; + (void)jcls; + result = (float)(float)SpecUtils::EnergyCalibration::sm_polynomial_offset_limit; + jresult = (jfloat)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_delete_1EnergyCalibration(JNIEnv *jenv, jclass jcls, jlong jarg1) { + SpecUtils::EnergyCalibration *arg1 = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(SpecUtils::EnergyCalibration **)&jarg1; + delete arg1; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_energy_1cal_1combine_1channels(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jlong jresult = 0 ; + SpecUtils::EnergyCalibration *arg1 = 0 ; + size_t arg2 ; + SwigValueWrapper< std::shared_ptr< SpecUtils::EnergyCalibration > > result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(SpecUtils::EnergyCalibration **)&jarg1; + if (!arg1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "SpecUtils::EnergyCalibration const & is null"); + return 0; + } + arg2 = (size_t)jarg2; + result = SpecUtils::energy_cal_combine_channels((SpecUtils::EnergyCalibration const &)*arg1,SWIG_STD_MOVE(arg2)); + *(std::shared_ptr< SpecUtils::EnergyCalibration > **)&jresult = new std::shared_ptr< SpecUtils::EnergyCalibration >(result); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_polynomial_1binning(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + std::vector< float > *arg1 = 0 ; + size_t arg2 ; + std::vector< std::pair< float,float > > *arg3 = 0 ; + std::shared_ptr< std::vector< float > const > result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + arg1 = (std::vector< float > *)((*(std::shared_ptr< const std::vector > **)&jarg1) ? (*(std::shared_ptr< const std::vector > **)&jarg1)->get() : 0); + if (!arg1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< float > const & reference is null"); + return 0; + } + arg2 = (size_t)jarg2; + arg3 = *(std::vector< std::pair< float,float > > **)&jarg3; + if (!arg3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< float,float > > const & is null"); + return 0; + } + result = SpecUtils::polynomial_binning((std::vector< float > const &)*arg1,SWIG_STD_MOVE(arg2),(std::vector< std::pair< float,float > > const &)*arg3); + *(std::shared_ptr< std::vector< float > const > **)&jresult = result ? new std::shared_ptr< std::vector< float > const >(result) : 0; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_fullrangefraction_1binning_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jboolean jarg4) { + jlong jresult = 0 ; + std::vector< float > *arg1 = 0 ; + size_t arg2 ; + std::vector< std::pair< float,float > > *arg3 = 0 ; + bool arg4 ; + std::shared_ptr< std::vector< float > const > result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + arg1 = (std::vector< float > *)((*(std::shared_ptr< const std::vector > **)&jarg1) ? (*(std::shared_ptr< const std::vector > **)&jarg1)->get() : 0); + if (!arg1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< float > const & reference is null"); + return 0; + } + arg2 = (size_t)jarg2; + arg3 = *(std::vector< std::pair< float,float > > **)&jarg3; + if (!arg3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< float,float > > const & is null"); + return 0; + } + arg4 = jarg4 ? true : false; + result = SpecUtils::fullrangefraction_binning((std::vector< float > const &)*arg1,SWIG_STD_MOVE(arg2),(std::vector< std::pair< float,float > > const &)*arg3,arg4); + *(std::shared_ptr< std::vector< float > const > **)&jresult = result ? new std::shared_ptr< std::vector< float > const >(result) : 0; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_fullrangefraction_1binning_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + std::vector< float > *arg1 = 0 ; + size_t arg2 ; + std::vector< std::pair< float,float > > *arg3 = 0 ; + std::shared_ptr< std::vector< float > const > result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + arg1 = (std::vector< float > *)((*(std::shared_ptr< const std::vector > **)&jarg1) ? (*(std::shared_ptr< const std::vector > **)&jarg1)->get() : 0); + if (!arg1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< float > const & reference is null"); + return 0; + } + arg2 = (size_t)jarg2; + arg3 = *(std::vector< std::pair< float,float > > **)&jarg3; + if (!arg3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< float,float > > const & is null"); + return 0; + } + result = SpecUtils::fullrangefraction_binning((std::vector< float > const &)*arg1,SWIG_STD_MOVE(arg2),(std::vector< std::pair< float,float > > const &)*arg3); + *(std::shared_ptr< std::vector< float > const > **)&jresult = result ? new std::shared_ptr< std::vector< float > const >(result) : 0; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_fullrangefraction_1energy(JNIEnv *jenv, jclass jcls, jdouble jarg1, jlong jarg2, jobject jarg2_, jlong jarg3, jlong jarg4) { + jdouble jresult = 0 ; + double arg1 ; + std::vector< float > *arg2 = 0 ; + size_t arg3 ; + std::vector< std::pair< float,float > > *arg4 = 0 ; + double result; + + (void)jenv; + (void)jcls; + (void)jarg2_; + arg1 = (double)jarg1; + + arg2 = (std::vector< float > *)((*(std::shared_ptr< const std::vector > **)&jarg2) ? (*(std::shared_ptr< const std::vector > **)&jarg2)->get() : 0); + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< float > const & reference is null"); + return 0; + } + arg3 = (size_t)jarg3; + arg4 = *(std::vector< std::pair< float,float > > **)&jarg4; + if (!arg4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< float,float > > const & is null"); + return 0; + } + result = (double)SpecUtils::fullrangefraction_energy(arg1,(std::vector< float > const &)*arg2,SWIG_STD_MOVE(arg3),(std::vector< std::pair< float,float > > const &)*arg4); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_polynomial_1energy(JNIEnv *jenv, jclass jcls, jdouble jarg1, jlong jarg2, jobject jarg2_, jlong jarg3) { + jdouble jresult = 0 ; + double arg1 ; + std::vector< float > *arg2 = 0 ; + std::vector< std::pair< float,float > > *arg3 = 0 ; + double result; + + (void)jenv; + (void)jcls; + (void)jarg2_; + arg1 = (double)jarg1; + + arg2 = (std::vector< float > *)((*(std::shared_ptr< const std::vector > **)&jarg2) ? (*(std::shared_ptr< const std::vector > **)&jarg2)->get() : 0); + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< float > const & reference is null"); + return 0; + } + arg3 = *(std::vector< std::pair< float,float > > **)&jarg3; + if (!arg3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< float,float > > const & is null"); + return 0; + } + result = (double)SpecUtils::polynomial_energy(arg1,(std::vector< float > const &)*arg2,(std::vector< std::pair< float,float > > const &)*arg3); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_deviation_1pair_1correction(JNIEnv *jenv, jclass jcls, jdouble jarg1, jlong jarg2) { + jdouble jresult = 0 ; + double arg1 ; + std::vector< std::pair< float,float > > *arg2 = 0 ; + double result; + + (void)jenv; + (void)jcls; + arg1 = (double)jarg1; + arg2 = *(std::vector< std::pair< float,float > > **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< float,float > > const & is null"); + return 0; + } + result = (double)SpecUtils::deviation_pair_correction(arg1,(std::vector< std::pair< float,float > > const &)*arg2); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_correction_1due_1to_1dev_1pairs(JNIEnv *jenv, jclass jcls, jdouble jarg1, jlong jarg2) { + jdouble jresult = 0 ; + double arg1 ; + std::vector< std::pair< float,float > > *arg2 = 0 ; + double result; + + (void)jenv; + (void)jcls; + arg1 = (double)jarg1; + arg2 = *(std::vector< std::pair< float,float > > **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< float,float > > const & is null"); + return 0; + } + result = (double)SpecUtils::correction_due_to_dev_pairs(arg1,(std::vector< std::pair< float,float > > const &)*arg2); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_apply_1deviation_1pair(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jlong jresult = 0 ; + std::vector< float > *arg1 = 0 ; + std::vector< std::pair< float,float > > *arg2 = 0 ; + std::shared_ptr< std::vector< float > const > result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + arg1 = (std::vector< float > *)((*(std::shared_ptr< const std::vector > **)&jarg1) ? (*(std::shared_ptr< const std::vector > **)&jarg1)->get() : 0); + if (!arg1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< float > const & reference is null"); + return 0; + } + arg2 = *(std::vector< std::pair< float,float > > **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< float,float > > const & is null"); + return 0; + } + result = SpecUtils::apply_deviation_pair((std::vector< float > const &)*arg1,(std::vector< std::pair< float,float > > const &)*arg2); + *(std::shared_ptr< std::vector< float > const > **)&jresult = result ? new std::shared_ptr< std::vector< float > const >(result) : 0; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_polynomial_1coef_1to_1fullrangefraction(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jlong jresult = 0 ; + std::vector< float > *arg1 = 0 ; + size_t arg2 ; + std::vector< float > result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + arg1 = (std::vector< float > *)((*(std::shared_ptr< const std::vector > **)&jarg1) ? (*(std::shared_ptr< const std::vector > **)&jarg1)->get() : 0); + if (!arg1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< float > const & reference is null"); + return 0; + } + arg2 = (size_t)jarg2; + result = SpecUtils::polynomial_coef_to_fullrangefraction((std::vector< float > const &)*arg1,SWIG_STD_MOVE(arg2)); + *(std::shared_ptr< std::vector > **)&jresult = new std::shared_ptr< std::vector >(new std::vector< float >(result)); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_fullrangefraction_1coef_1to_1polynomial(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jlong jresult = 0 ; + std::vector< float > *arg1 = 0 ; + size_t arg2 ; + std::vector< float > result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + arg1 = (std::vector< float > *)((*(std::shared_ptr< const std::vector > **)&jarg1) ? (*(std::shared_ptr< const std::vector > **)&jarg1)->get() : 0); + if (!arg1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< float > const & reference is null"); + return 0; + } + arg2 = (size_t)jarg2; + result = SpecUtils::fullrangefraction_coef_to_polynomial((std::vector< float > const &)*arg1,SWIG_STD_MOVE(arg2)); + *(std::shared_ptr< std::vector > **)&jresult = new std::shared_ptr< std::vector >(new std::vector< float >(result)); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_mid_1channel_1polynomial_1to_1fullrangeFraction(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + jlong jresult = 0 ; + std::vector< float > *arg1 = 0 ; + size_t arg2 ; + std::vector< float > result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + + arg1 = (std::vector< float > *)((*(std::shared_ptr< const std::vector > **)&jarg1) ? (*(std::shared_ptr< const std::vector > **)&jarg1)->get() : 0); + if (!arg1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< float > const & reference is null"); + return 0; + } + arg2 = (size_t)jarg2; + result = SpecUtils::mid_channel_polynomial_to_fullrangeFraction((std::vector< float > const &)*arg1,SWIG_STD_MOVE(arg2)); + *(std::shared_ptr< std::vector > **)&jresult = new std::shared_ptr< std::vector >(new std::vector< float >(result)); + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_calibration_1is_1valid(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_, jlong jarg3, jlong jarg4) { + jboolean jresult = 0 ; + SpecUtils::EnergyCalType arg1 ; + std::vector< float > *arg2 = 0 ; + std::vector< std::pair< float,float > > *arg3 = 0 ; + size_t arg4 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg2_; + arg1 = (SpecUtils::EnergyCalType)jarg1; + + arg2 = (std::vector< float > *)((*(std::shared_ptr< const std::vector > **)&jarg2) ? (*(std::shared_ptr< const std::vector > **)&jarg2)->get() : 0); + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< float > const & reference is null"); + return 0; + } + arg3 = *(std::vector< std::pair< float,float > > **)&jarg3; + if (!arg3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< float,float > > const & is null"); + return 0; + } + arg4 = (size_t)jarg4; + result = (bool)SpecUtils::calibration_is_valid(arg1,(std::vector< float > const &)*arg2,(std::vector< std::pair< float,float > > const &)*arg3,SWIG_STD_MOVE(arg4)); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_polynomial_1cal_1remove_1first_1channels(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) { + jlong jresult = 0 ; + int arg1 ; + std::vector< float > *arg2 = 0 ; + std::vector< float > result; + + (void)jenv; + (void)jcls; + (void)jarg2_; + arg1 = (int)jarg1; + + arg2 = (std::vector< float > *)((*(std::shared_ptr< const std::vector > **)&jarg2) ? (*(std::shared_ptr< const std::vector > **)&jarg2)->get() : 0); + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< float > const & reference is null"); + return 0; + } + result = SpecUtils::polynomial_cal_remove_first_channels(arg1,(std::vector< float > const &)*arg2); + *(std::shared_ptr< std::vector > **)&jresult = new std::shared_ptr< std::vector >(new std::vector< float >(result)); + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_find_1fullrangefraction_1channel_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jdouble jarg1, jlong jarg2, jobject jarg2_, jlong jarg3, jlong jarg4, jdouble jarg5) { + jdouble jresult = 0 ; + double arg1 ; + std::vector< float > *arg2 = 0 ; + size_t arg3 ; + std::vector< std::pair< float,float > > *arg4 = 0 ; + double arg5 ; + double result; + + (void)jenv; + (void)jcls; + (void)jarg2_; + arg1 = (double)jarg1; + + arg2 = (std::vector< float > *)((*(std::shared_ptr< const std::vector > **)&jarg2) ? (*(std::shared_ptr< const std::vector > **)&jarg2)->get() : 0); + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< float > const & reference is null"); + return 0; + } + arg3 = (size_t)jarg3; + arg4 = *(std::vector< std::pair< float,float > > **)&jarg4; + if (!arg4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< float,float > > const & is null"); + return 0; + } + arg5 = (double)jarg5; + result = (double)SpecUtils::find_fullrangefraction_channel(arg1,(std::vector< float > const &)*arg2,SWIG_STD_MOVE(arg3),(std::vector< std::pair< float,float > > const &)*arg4,arg5); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_find_1fullrangefraction_1channel_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jdouble jarg1, jlong jarg2, jobject jarg2_, jlong jarg3, jlong jarg4) { + jdouble jresult = 0 ; + double arg1 ; + std::vector< float > *arg2 = 0 ; + size_t arg3 ; + std::vector< std::pair< float,float > > *arg4 = 0 ; + double result; + + (void)jenv; + (void)jcls; + (void)jarg2_; + arg1 = (double)jarg1; + + arg2 = (std::vector< float > *)((*(std::shared_ptr< const std::vector > **)&jarg2) ? (*(std::shared_ptr< const std::vector > **)&jarg2)->get() : 0); + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< float > const & reference is null"); + return 0; + } + arg3 = (size_t)jarg3; + arg4 = *(std::vector< std::pair< float,float > > **)&jarg4; + if (!arg4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< float,float > > const & is null"); + return 0; + } + result = (double)SpecUtils::find_fullrangefraction_channel(arg1,(std::vector< float > const &)*arg2,SWIG_STD_MOVE(arg3),(std::vector< std::pair< float,float > > const &)*arg4); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_find_1polynomial_1channel_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jdouble jarg1, jlong jarg2, jobject jarg2_, jlong jarg3, jlong jarg4, jdouble jarg5) { + jdouble jresult = 0 ; + double arg1 ; + std::vector< float > *arg2 = 0 ; + size_t arg3 ; + std::vector< std::pair< float,float > > *arg4 = 0 ; + double arg5 ; + double result; + + (void)jenv; + (void)jcls; + (void)jarg2_; + arg1 = (double)jarg1; + + arg2 = (std::vector< float > *)((*(std::shared_ptr< const std::vector > **)&jarg2) ? (*(std::shared_ptr< const std::vector > **)&jarg2)->get() : 0); + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< float > const & reference is null"); + return 0; + } + arg3 = (size_t)jarg3; + arg4 = *(std::vector< std::pair< float,float > > **)&jarg4; + if (!arg4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< float,float > > const & is null"); + return 0; + } + arg5 = (double)jarg5; + result = (double)SpecUtils::find_polynomial_channel(arg1,(std::vector< float > const &)*arg2,SWIG_STD_MOVE(arg3),(std::vector< std::pair< float,float > > const &)*arg4,arg5); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT jdouble JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_find_1polynomial_1channel_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jdouble jarg1, jlong jarg2, jobject jarg2_, jlong jarg3, jlong jarg4) { + jdouble jresult = 0 ; + double arg1 ; + std::vector< float > *arg2 = 0 ; + size_t arg3 ; + std::vector< std::pair< float,float > > *arg4 = 0 ; + double result; + + (void)jenv; + (void)jcls; + (void)jarg2_; + arg1 = (double)jarg1; + + arg2 = (std::vector< float > *)((*(std::shared_ptr< const std::vector > **)&jarg2) ? (*(std::shared_ptr< const std::vector > **)&jarg2)->get() : 0); + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< float > const & reference is null"); + return 0; + } + arg3 = (size_t)jarg3; + arg4 = *(std::vector< std::pair< float,float > > **)&jarg4; + if (!arg4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< float,float > > const & is null"); + return 0; + } + result = (double)SpecUtils::find_polynomial_channel(arg1,(std::vector< float > const &)*arg2,SWIG_STD_MOVE(arg3),(std::vector< std::pair< float,float > > const &)*arg4); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_rebin_1by_1lower_1edge(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_) { + std::vector< float > *arg1 = 0 ; + std::vector< float > *arg2 = 0 ; + std::vector< float > *arg3 = 0 ; + std::vector< float > *arg4 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + (void)jarg2_; + (void)jarg3_; + (void)jarg4_; + + arg1 = (std::vector< float > *)((*(std::shared_ptr< const std::vector > **)&jarg1) ? (*(std::shared_ptr< const std::vector > **)&jarg1)->get() : 0); + if (!arg1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< float > const & reference is null"); + return ; + } + + arg2 = (std::vector< float > *)((*(std::shared_ptr< const std::vector > **)&jarg2) ? (*(std::shared_ptr< const std::vector > **)&jarg2)->get() : 0); + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< float > const & reference is null"); + return ; + } + + arg3 = (std::vector< float > *)((*(std::shared_ptr< const std::vector > **)&jarg3) ? (*(std::shared_ptr< const std::vector > **)&jarg3)->get() : 0); + if (!arg3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< float > const & reference is null"); + return ; + } + + arg4 = (std::vector< float > *)((*(std::shared_ptr< std::vector > **)&jarg4) ? (*(std::shared_ptr< std::vector > **)&jarg4)->get() : 0); + if (!arg4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< float > & reference is null"); + return ; + } + SpecUtils::rebin_by_lower_edge((std::vector< float > const &)*arg1,(std::vector< float > const &)*arg2,(std::vector< float > const &)*arg3,*arg4); +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_energy_1cal_1from_1CALp_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3) { + jlong jresult = 0 ; + std::istream *arg1 = 0 ; + size_t arg2 ; + std::string *arg3 = 0 ; + SwigValueWrapper< std::shared_ptr< SpecUtils::EnergyCalibration > > result; + + (void)jenv; + (void)jcls; + arg1 = *(std::istream **)&jarg1; + if (!arg1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::istream & is null"); + return 0; + } + arg2 = (size_t)jarg2; + arg3 = *(std::string **)&jarg3; + if (!arg3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::string & is null"); + return 0; + } + result = SpecUtils::energy_cal_from_CALp_file(*arg1,SWIG_STD_MOVE(arg2),*arg3); + *(std::shared_ptr< SpecUtils::EnergyCalibration > **)&jresult = new std::shared_ptr< SpecUtils::EnergyCalibration >(result); + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_write_1CALp_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jstring jarg3) { + jboolean jresult = 0 ; + std::ostream *arg1 = 0 ; + std::shared_ptr< SpecUtils::EnergyCalibration const > *arg2 = 0 ; + std::string *arg3 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + arg1 = *(std::ostream **)&jarg1; + if (!arg1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::ostream & is null"); + return 0; + } + arg2 = *(std::shared_ptr< SpecUtils::EnergyCalibration const > **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::shared_ptr< SpecUtils::EnergyCalibration const > const & is null"); + return 0; + } + if(!jarg3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); + if (!arg3_pstr) return 0; + std::string arg3_str(arg3_pstr); + arg3 = &arg3_str; + jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); + result = (bool)SpecUtils::write_CALp_file(*arg1,(std::shared_ptr< SpecUtils::EnergyCalibration const > const &)*arg2,(std::string const &)*arg3); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3_1MIN_1JS_1get(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + unsigned char *result = 0 ; + + (void)jenv; + (void)jcls; + result = (unsigned char *)(unsigned char *)D3_MIN_JS; + *(unsigned char **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3_1MIN_1JS_1SIZE_1get(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + size_t result; + + (void)jenv; + (void)jcls; + result = (size_t)D3_MIN_JS_SIZE; + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SPECTRUM_1CHART_1D3_1JS_1get(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + unsigned char *result = 0 ; + + (void)jenv; + (void)jcls; + result = (unsigned char *)(unsigned char *)SPECTRUM_CHART_D3_JS; + *(unsigned char **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SPECTRUM_1CHART_1D3_1JS_1SIZE_1get(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + size_t result; + + (void)jenv; + (void)jcls; + result = (size_t)SPECTRUM_CHART_D3_JS_SIZE; + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SPECTRUM_1CHART_1D3_1CSS_1get(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + unsigned char *result = 0 ; + + (void)jenv; + (void)jcls; + result = (unsigned char *)(unsigned char *)SPECTRUM_CHART_D3_CSS; + *(unsigned char **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SPECTRUM_1CHART_1D3_1CSS_1SIZE_1get(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + size_t result; + + (void)jenv; + (void)jcls; + result = (size_t)SPECTRUM_CHART_D3_CSS_SIZE; + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SPECTRUM_1CHART_1D3_1STANDALONE_1CSS_1get(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + unsigned char *result = 0 ; + + (void)jenv; + (void)jcls; + result = (unsigned char *)(unsigned char *)SPECTRUM_CHART_D3_STANDALONE_CSS; + *(unsigned char **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_SPECTRUM_1CHART_1D3_1STANDALONE_1CSS_1SIZE_1get(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + size_t result; + + (void)jenv; + (void)jcls; + result = (size_t)SPECTRUM_CHART_D3_STANDALONE_CSS_SIZE; + jresult = (jlong)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_write_1spectrum_1data_1js(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jint jarg5) { + jboolean jresult = 0 ; + std::ostream *arg1 = 0 ; + SpecUtils::Measurement *arg2 = 0 ; + D3SpectrumExport::D3SpectrumOptions *arg3 = 0 ; + size_t arg4 ; + int arg5 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg2_; + (void)jarg3_; + arg1 = *(std::ostream **)&jarg1; + if (!arg1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::ostream & is null"); + return 0; + } + + arg2 = (SpecUtils::Measurement *)((*(std::shared_ptr< const SpecUtils::Measurement > **)&jarg2) ? (*(std::shared_ptr< const SpecUtils::Measurement > **)&jarg2)->get() : 0); + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "SpecUtils::Measurement const & reference is null"); + return 0; + } + arg3 = *(D3SpectrumExport::D3SpectrumOptions **)&jarg3; + if (!arg3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "D3SpectrumExport::D3SpectrumOptions const & is null"); + return 0; + } + arg4 = (size_t)jarg4; + arg5 = (int)jarg5; + result = (bool)D3SpectrumExport::write_spectrum_data_js(*arg1,(SpecUtils::Measurement const &)*arg2,(D3SpectrumExport::D3SpectrumOptions const &)*arg3,SWIG_STD_MOVE(arg4),arg5); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_write_1d3_1html(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2, jlong jarg3, jobject jarg3_) { + jboolean jresult = 0 ; + std::ostream *arg1 = 0 ; + std::vector< std::pair< SpecUtils::Measurement const *,D3SpectrumExport::D3SpectrumOptions > > *arg2 = 0 ; + D3SpectrumExport::D3SpectrumChartOptions *arg3 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg3_; + arg1 = *(std::ostream **)&jarg1; + if (!arg1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::ostream & is null"); + return 0; + } + arg2 = *(std::vector< std::pair< SpecUtils::Measurement const *,D3SpectrumExport::D3SpectrumOptions > > **)&jarg2; + if (!arg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< SpecUtils::Measurement const *,D3SpectrumExport::D3SpectrumOptions > > const & is null"); + return 0; + } + arg3 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg3; + if (!arg3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "D3SpectrumExport::D3SpectrumChartOptions const & is null"); + return 0; + } + result = (bool)D3SpectrumExport::write_d3_html(*arg1,(std::vector< std::pair< SpecUtils::Measurement const *,D3SpectrumExport::D3SpectrumOptions > > const &)*arg2,(D3SpectrumExport::D3SpectrumChartOptions const &)*arg3); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_write_1html_1page_1header(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2) { + jboolean jresult = 0 ; + std::ostream *arg1 = 0 ; + std::string *arg2 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + arg1 = *(std::ostream **)&jarg1; + if (!arg1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::ostream & is null"); + return 0; + } + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return 0; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + result = (bool)D3SpectrumExport::write_html_page_header(*arg1,(std::string const &)*arg2); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_write_1js_1for_1chart(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jstring jarg3, jstring jarg4, jstring jarg5) { + jboolean jresult = 0 ; + std::ostream *arg1 = 0 ; + std::string *arg2 = 0 ; + std::string *arg3 = 0 ; + std::string *arg4 = 0 ; + std::string *arg5 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + arg1 = *(std::ostream **)&jarg1; + if (!arg1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::ostream & is null"); + return 0; + } + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return 0; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + if(!jarg3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); + if (!arg3_pstr) return 0; + std::string arg3_str(arg3_pstr); + arg3 = &arg3_str; + jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); + if(!jarg4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg4_pstr = jenv->GetStringUTFChars(jarg4, 0); + if (!arg4_pstr) return 0; + std::string arg4_str(arg4_pstr); + arg4 = &arg4_str; + jenv->ReleaseStringUTFChars(jarg4, arg4_pstr); + if(!jarg5) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg5_pstr = jenv->GetStringUTFChars(jarg5, 0); + if (!arg5_pstr) return 0; + std::string arg5_str(arg5_pstr); + arg5 = &arg5_str; + jenv->ReleaseStringUTFChars(jarg5, arg5_pstr); + result = (bool)D3SpectrumExport::write_js_for_chart(*arg1,(std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_write_1and_1set_1data_1for_1chart(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3) { + jboolean jresult = 0 ; + std::ostream *arg1 = 0 ; + std::string *arg2 = 0 ; + std::vector< std::pair< SpecUtils::Measurement const *,D3SpectrumExport::D3SpectrumOptions > > *arg3 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + arg1 = *(std::ostream **)&jarg1; + if (!arg1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::ostream & is null"); + return 0; + } + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return 0; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + arg3 = *(std::vector< std::pair< SpecUtils::Measurement const *,D3SpectrumExport::D3SpectrumOptions > > **)&jarg3; + if (!arg3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< SpecUtils::Measurement const *,D3SpectrumExport::D3SpectrumOptions > > const & is null"); + return 0; + } + result = (bool)D3SpectrumExport::write_and_set_data_for_chart(*arg1,(std::string const &)*arg2,(std::vector< std::pair< SpecUtils::Measurement const *,D3SpectrumExport::D3SpectrumOptions > > const &)*arg3); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_write_1set_1options_1for_1chart(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3, jobject jarg3_) { + jboolean jresult = 0 ; + std::ostream *arg1 = 0 ; + std::string *arg2 = 0 ; + D3SpectrumExport::D3SpectrumChartOptions *arg3 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg3_; + arg1 = *(std::ostream **)&jarg1; + if (!arg1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::ostream & is null"); + return 0; + } + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return 0; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + arg3 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg3; + if (!arg3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "D3SpectrumExport::D3SpectrumChartOptions const & is null"); + return 0; + } + result = (bool)D3SpectrumExport::write_set_options_for_chart(*arg1,(std::string const &)*arg2,(D3SpectrumExport::D3SpectrumChartOptions const &)*arg3); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_write_1html_1display_1options_1for_1chart(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2, jlong jarg3, jobject jarg3_) { + jboolean jresult = 0 ; + std::ostream *arg1 = 0 ; + std::string *arg2 = 0 ; + D3SpectrumExport::D3SpectrumChartOptions *arg3 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg3_; + arg1 = *(std::ostream **)&jarg1; + if (!arg1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::ostream & is null"); + return 0; + } + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return 0; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + arg3 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg3; + if (!arg3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "D3SpectrumExport::D3SpectrumChartOptions const & is null"); + return 0; + } + result = (bool)D3SpectrumExport::write_html_display_options_for_chart(*arg1,(std::string const &)*arg2,(D3SpectrumExport::D3SpectrumChartOptions const &)*arg3); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_d3_1js(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + unsigned char *result = 0 ; + + (void)jenv; + (void)jcls; + result = (unsigned char *)D3SpectrumExport::d3_js(); + *(unsigned char **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_spectrum_1chart_1d3_1js(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + unsigned char *result = 0 ; + + (void)jenv; + (void)jcls; + result = (unsigned char *)D3SpectrumExport::spectrum_chart_d3_js(); + *(unsigned char **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_spectrum_1char_1d3_1css(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + unsigned char *result = 0 ; + + (void)jenv; + (void)jcls; + result = (unsigned char *)D3SpectrumExport::spectrum_char_d3_css(); + *(unsigned char **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_spectrum_1chart_1d3_1standalone_1css(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + unsigned char *result = 0 ; + + (void)jenv; + (void)jcls; + result = (unsigned char *)D3SpectrumExport::spectrum_chart_d3_standalone_css(); + *(unsigned char **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_spectrum_1chart_1setup_1js(JNIEnv *jenv, jclass jcls) { + jstring jresult = 0 ; + char *result = 0 ; + + (void)jenv; + (void)jcls; + result = (char *)D3SpectrumExport::spectrum_chart_setup_js(); + if (result) jresult = jenv->NewStringUTF((const char *)result); + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_new_1D3SpectrumOptions(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + D3SpectrumExport::D3SpectrumOptions *result = 0 ; + + (void)jenv; + (void)jcls; + result = (D3SpectrumExport::D3SpectrumOptions *)new D3SpectrumExport::D3SpectrumOptions(); + *(D3SpectrumExport::D3SpectrumOptions **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumOptions_1peaks_1json_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + D3SpectrumExport::D3SpectrumOptions *arg1 = 0 ; + std::string *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumOptions **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + if (arg1) (arg1)->peaks_json = *arg2; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumOptions_1peaks_1json_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + D3SpectrumExport::D3SpectrumOptions *arg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumOptions **)&jarg1; + result = (std::string *) & ((arg1)->peaks_json); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumOptions_1line_1color_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + D3SpectrumExport::D3SpectrumOptions *arg1 = 0 ; + std::string *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumOptions **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + if (arg1) (arg1)->line_color = *arg2; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumOptions_1line_1color_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + D3SpectrumExport::D3SpectrumOptions *arg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumOptions **)&jarg1; + result = (std::string *) & ((arg1)->line_color); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumOptions_1peak_1color_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + D3SpectrumExport::D3SpectrumOptions *arg1 = 0 ; + std::string *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumOptions **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + if (arg1) (arg1)->peak_color = *arg2; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumOptions_1peak_1color_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + D3SpectrumExport::D3SpectrumOptions *arg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumOptions **)&jarg1; + result = (std::string *) & ((arg1)->peak_color); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumOptions_1title_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + D3SpectrumExport::D3SpectrumOptions *arg1 = 0 ; + std::string *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumOptions **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + if (arg1) (arg1)->title = *arg2; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumOptions_1title_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + D3SpectrumExport::D3SpectrumOptions *arg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumOptions **)&jarg1; + result = (std::string *) & ((arg1)->title); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumOptions_1display_1scale_1factor_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) { + D3SpectrumExport::D3SpectrumOptions *arg1 = 0 ; + double arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumOptions **)&jarg1; + arg2 = (double)jarg2; + if (arg1) (arg1)->display_scale_factor = arg2; +} + + +SWIGEXPORT jdouble JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumOptions_1display_1scale_1factor_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jdouble jresult = 0 ; + D3SpectrumExport::D3SpectrumOptions *arg1 = 0 ; + double result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumOptions **)&jarg1; + result = (double) ((arg1)->display_scale_factor); + jresult = (jdouble)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumOptions_1spectrum_1type_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) { + D3SpectrumExport::D3SpectrumOptions *arg1 = 0 ; + SpecUtils::SpectrumType arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumOptions **)&jarg1; + arg2 = (SpecUtils::SpectrumType)jarg2; + if (arg1) (arg1)->spectrum_type = arg2; +} + + +SWIGEXPORT jint JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumOptions_1spectrum_1type_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jint jresult = 0 ; + D3SpectrumExport::D3SpectrumOptions *arg1 = 0 ; + SpecUtils::SpectrumType result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumOptions **)&jarg1; + result = (SpecUtils::SpectrumType) ((arg1)->spectrum_type); + jresult = (jint)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_delete_1D3SpectrumOptions(JNIEnv *jenv, jclass jcls, jlong jarg1) { + D3SpectrumExport::D3SpectrumOptions *arg1 = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(D3SpectrumExport::D3SpectrumOptions **)&jarg1; + delete arg1; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_new_1D3SpectrumChartOptions_1_1SWIG_10(JNIEnv *jenv, jclass jcls) { + jlong jresult = 0 ; + D3SpectrumExport::D3SpectrumChartOptions *result = 0 ; + + (void)jenv; + (void)jcls; + result = (D3SpectrumExport::D3SpectrumChartOptions *)new D3SpectrumExport::D3SpectrumChartOptions(); + *(D3SpectrumExport::D3SpectrumChartOptions **)&jresult = result; + return jresult; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_new_1D3SpectrumChartOptions_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2, jstring jarg3, jstring jarg4, jboolean jarg5, jboolean jarg6, jboolean jarg7, jboolean jarg8, jboolean jarg9, jboolean jarg10, jboolean jarg11, jboolean jarg12, jboolean jarg13, jboolean jarg14, jboolean jarg15, jboolean jarg16, jboolean jarg17, jboolean jarg18, jfloat jarg19, jfloat jarg20, jlong jarg21) { + jlong jresult = 0 ; + std::string arg1 ; + std::string arg2 ; + std::string arg3 ; + std::string arg4 ; + bool arg5 ; + bool arg6 ; + bool arg7 ; + bool arg8 ; + bool arg9 ; + bool arg10 ; + bool arg11 ; + bool arg12 ; + bool arg13 ; + bool arg14 ; + bool arg15 ; + bool arg16 ; + bool arg17 ; + bool arg18 ; + float arg19 ; + float arg20 ; + SwigValueWrapper< std::map< std::string,std::string > > arg21 ; + std::map< std::string,std::string > *argp21 ; + D3SpectrumExport::D3SpectrumChartOptions *result = 0 ; + + (void)jenv; + (void)jcls; + if(!jarg1) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg1_pstr = jenv->GetStringUTFChars(jarg1, 0); + if (!arg1_pstr) return 0; + (&arg1)->assign(arg1_pstr); + jenv->ReleaseStringUTFChars(jarg1, arg1_pstr); + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return 0; + (&arg2)->assign(arg2_pstr); + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + if(!jarg3) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); + if (!arg3_pstr) return 0; + (&arg3)->assign(arg3_pstr); + jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); + if(!jarg4) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return 0; + } + const char *arg4_pstr = jenv->GetStringUTFChars(jarg4, 0); + if (!arg4_pstr) return 0; + (&arg4)->assign(arg4_pstr); + jenv->ReleaseStringUTFChars(jarg4, arg4_pstr); + arg5 = jarg5 ? true : false; + arg6 = jarg6 ? true : false; + arg7 = jarg7 ? true : false; + arg8 = jarg8 ? true : false; + arg9 = jarg9 ? true : false; + arg10 = jarg10 ? true : false; + arg11 = jarg11 ? true : false; + arg12 = jarg12 ? true : false; + arg13 = jarg13 ? true : false; + arg14 = jarg14 ? true : false; + arg15 = jarg15 ? true : false; + arg16 = jarg16 ? true : false; + arg17 = jarg17 ? true : false; + arg18 = jarg18 ? true : false; + arg19 = (float)jarg19; + arg20 = (float)jarg20; + argp21 = *(std::map< std::string,std::string > **)&jarg21; + if (!argp21) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< std::string,std::string >"); + return 0; + } + arg21 = *argp21; + result = (D3SpectrumExport::D3SpectrumChartOptions *)new D3SpectrumExport::D3SpectrumChartOptions(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,SWIG_STD_MOVE(arg21)); + *(D3SpectrumExport::D3SpectrumChartOptions **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1title_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + std::string *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + if (arg1) (arg1)->m_title = *arg2; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1title_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + result = (std::string *) & ((arg1)->m_title); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1xAxisTitle_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + std::string *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + if (arg1) (arg1)->m_xAxisTitle = *arg2; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1xAxisTitle_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + result = (std::string *) & ((arg1)->m_xAxisTitle); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1yAxisTitle_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + std::string *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + if (arg1) (arg1)->m_yAxisTitle = *arg2; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1yAxisTitle_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + result = (std::string *) & ((arg1)->m_yAxisTitle); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1dataTitle_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) { + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + std::string *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + if(!jarg2) { + SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string"); + return ; + } + const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); + if (!arg2_pstr) return ; + std::string arg2_str(arg2_pstr); + arg2 = &arg2_str; + jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); + if (arg1) (arg1)->m_dataTitle = *arg2; +} + + +SWIGEXPORT jstring JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1dataTitle_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jstring jresult = 0 ; + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + std::string *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + result = (std::string *) & ((arg1)->m_dataTitle); + jresult = jenv->NewStringUTF(result->c_str()); + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1useLogYAxis_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + bool arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + arg2 = jarg2 ? true : false; + if (arg1) (arg1)->m_useLogYAxis = arg2; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1useLogYAxis_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + result = (bool) ((arg1)->m_useLogYAxis); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1showVerticalGridLines_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + bool arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + arg2 = jarg2 ? true : false; + if (arg1) (arg1)->m_showVerticalGridLines = arg2; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1showVerticalGridLines_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + result = (bool) ((arg1)->m_showVerticalGridLines); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1showHorizontalGridLines_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + bool arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + arg2 = jarg2 ? true : false; + if (arg1) (arg1)->m_showHorizontalGridLines = arg2; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1showHorizontalGridLines_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + result = (bool) ((arg1)->m_showHorizontalGridLines); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1legendEnabled_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + bool arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + arg2 = jarg2 ? true : false; + if (arg1) (arg1)->m_legendEnabled = arg2; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1legendEnabled_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + result = (bool) ((arg1)->m_legendEnabled); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1compactXAxis_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + bool arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + arg2 = jarg2 ? true : false; + if (arg1) (arg1)->m_compactXAxis = arg2; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1compactXAxis_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + result = (bool) ((arg1)->m_compactXAxis); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1showPeakUserLabels_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + bool arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + arg2 = jarg2 ? true : false; + if (arg1) (arg1)->m_showPeakUserLabels = arg2; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1showPeakUserLabels_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + result = (bool) ((arg1)->m_showPeakUserLabels); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1showPeakEnergyLabels_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + bool arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + arg2 = jarg2 ? true : false; + if (arg1) (arg1)->m_showPeakEnergyLabels = arg2; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1showPeakEnergyLabels_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + result = (bool) ((arg1)->m_showPeakEnergyLabels); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1showPeakNuclideLabels_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + bool arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + arg2 = jarg2 ? true : false; + if (arg1) (arg1)->m_showPeakNuclideLabels = arg2; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1showPeakNuclideLabels_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + result = (bool) ((arg1)->m_showPeakNuclideLabels); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1showPeakNuclideEnergyLabels_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + bool arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + arg2 = jarg2 ? true : false; + if (arg1) (arg1)->m_showPeakNuclideEnergyLabels = arg2; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1showPeakNuclideEnergyLabels_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + result = (bool) ((arg1)->m_showPeakNuclideEnergyLabels); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1showEscapePeakMarker_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + bool arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + arg2 = jarg2 ? true : false; + if (arg1) (arg1)->m_showEscapePeakMarker = arg2; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1showEscapePeakMarker_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + result = (bool) ((arg1)->m_showEscapePeakMarker); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1showComptonPeakMarker_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + bool arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + arg2 = jarg2 ? true : false; + if (arg1) (arg1)->m_showComptonPeakMarker = arg2; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1showComptonPeakMarker_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + result = (bool) ((arg1)->m_showComptonPeakMarker); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1showComptonEdgeMarker_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + bool arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + arg2 = jarg2 ? true : false; + if (arg1) (arg1)->m_showComptonEdgeMarker = arg2; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1showComptonEdgeMarker_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + result = (bool) ((arg1)->m_showComptonEdgeMarker); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1showSumPeakMarker_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + bool arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + arg2 = jarg2 ? true : false; + if (arg1) (arg1)->m_showSumPeakMarker = arg2; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1showSumPeakMarker_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + result = (bool) ((arg1)->m_showSumPeakMarker); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1backgroundSubtract_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + bool arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + arg2 = jarg2 ? true : false; + if (arg1) (arg1)->m_backgroundSubtract = arg2; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1backgroundSubtract_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + result = (bool) ((arg1)->m_backgroundSubtract); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1allowDragRoiExtent_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) { + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + bool arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + arg2 = jarg2 ? true : false; + if (arg1) (arg1)->m_allowDragRoiExtent = arg2; +} + + +SWIGEXPORT jboolean JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1allowDragRoiExtent_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jboolean jresult = 0 ; + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + bool result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + result = (bool) ((arg1)->m_allowDragRoiExtent); + jresult = (jboolean)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1xMin_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + float arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->m_xMin = arg2; +} + + +SWIGEXPORT jfloat JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1xMin_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jfloat jresult = 0 ; + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + float result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + result = (float) ((arg1)->m_xMin); + jresult = (jfloat)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1xMax_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) { + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + float arg2 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + arg2 = (float)jarg2; + if (arg1) (arg1)->m_xMax = arg2; +} + + +SWIGEXPORT jfloat JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1xMax_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jfloat jresult = 0 ; + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + float result; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + result = (float) ((arg1)->m_xMax); + jresult = (jfloat)result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1reference_1lines_1json_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) { + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + std::map< std::string,std::string > *arg2 = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + arg2 = *(std::map< std::string,std::string > **)&jarg2; + if (arg1) (arg1)->m_reference_lines_json = *arg2; +} + + +SWIGEXPORT jlong JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_D3SpectrumChartOptions_1m_1reference_1lines_1json_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) { + jlong jresult = 0 ; + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + std::map< std::string,std::string > *result = 0 ; + + (void)jenv; + (void)jcls; + (void)jarg1_; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + result = (std::map< std::string,std::string > *)& ((arg1)->m_reference_lines_json); + *(std::map< std::string,std::string > **)&jresult = result; + return jresult; +} + + +SWIGEXPORT void JNICALL Java_gov_sandia_specutils_SpecUtilsSwigJNI_delete_1D3SpectrumChartOptions(JNIEnv *jenv, jclass jcls, jlong jarg1) { + D3SpectrumExport::D3SpectrumChartOptions *arg1 = 0 ; + + (void)jenv; + (void)jcls; + arg1 = *(D3SpectrumExport::D3SpectrumChartOptions **)&jarg1; + delete arg1; +} + + +#ifdef __cplusplus +} +#endif diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SpecUtilsNativeLoader.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SpecUtilsNativeLoader.java new file mode 100644 index 00000000..8eb4cefc --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SpecUtilsNativeLoader.java @@ -0,0 +1,47 @@ +package gov.sandia.specutils; + +/** + * Thread-safe loader for SpecUtils JNI native libraries. + * Loads both libSpecUtils (core C++ library) and libSpecUtilsJni (SWIG JNI bridge) + * in the correct dependency order. + * + * In production, the NativeClassLoader extracts these from classpath JARs + * (lib/native/{os}/{arch}/ resources). In tests, java.library.path must be set + * to point at the appropriate native lib directory. + */ +public class SpecUtilsNativeLoader { + + private static volatile boolean loaded = false; + private static volatile boolean available = false; + + /** + * Attempts to load the SpecUtils native libraries. + * Safe to call multiple times; loading only occurs once. + * + * @return true if the native libraries are available, false otherwise + */ + public static boolean load() { + if (!loaded) { + synchronized (SpecUtilsNativeLoader.class) { + if (!loaded) { + try { + System.loadLibrary("SpecUtils"); + System.loadLibrary("SpecUtilsJni"); + available = true; + } catch (UnsatisfiedLinkError e) { + available = false; + } + loaded = true; + } + } + } + return available; + } + + /** + * @return true if the native libraries have been successfully loaded + */ + public static boolean isAvailable() { + return available; + } +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SpecUtilsSwig.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SpecUtilsSwig.java new file mode 100644 index 00000000..092f19f1 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SpecUtilsSwig.java @@ -0,0 +1,241 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class SpecUtilsSwig implements SpecUtilsSwigConstants { + public static SWIGTYPE_p_std__ostream openFile(String filename) { + long cPtr = SpecUtilsSwigJNI.openFile(filename); + return (cPtr == 0) ? null : new SWIGTYPE_p_std__ostream(cPtr, false); + } + + public static void closeFile(SWIGTYPE_p_std__ostream stream) { + SpecUtilsSwigJNI.closeFile(SWIGTYPE_p_std__ostream.getCPtr(stream)); + } + + public static String descriptionText(SpectrumType type) { + return SpecUtilsSwigJNI.descriptionText__SWIG_0(type.swigValue()); + } + + public static SpectrumType spectrumTypeFromDescription(String descrip) { + return SpectrumType.swigToEnum(SpecUtilsSwigJNI.spectrumTypeFromDescription(descrip)); + } + + public static String suggestedNameEnding(SaveSpectrumAsType type) { + return SpecUtilsSwigJNI.suggestedNameEnding(type.swigValue()); + } + + public static String descriptionText(SaveSpectrumAsType type) { + return SpecUtilsSwigJNI.descriptionText__SWIG_1(type.swigValue()); + } + + public static boolean is_candidate_n42_file(String data) { + return SpecUtilsSwigJNI.is_candidate_n42_file__SWIG_0(data); + } + + public static boolean is_candidate_n42_file(String data, String data_end) { + return SpecUtilsSwigJNI.is_candidate_n42_file__SWIG_1(data, data_end); + } + + public static String convert_n42_utf16_xml_to_utf8(String data, String data_end) { + return SpecUtilsSwigJNI.convert_n42_utf16_xml_to_utf8(data, data_end); + } + + public static void add_analysis_results_to_2012_N42(DetectorAnalysis ana, SWIGTYPE_p_rapidxml__xml_nodeT_char_t RadInstrumentData, SWIGTYPE_p_std__mutex xmldocmutex) { + SpecUtilsSwigJNI.add_analysis_results_to_2012_N42(DetectorAnalysis.getCPtr(ana), ana, SWIGTYPE_p_rapidxml__xml_nodeT_char_t.getCPtr(RadInstrumentData), SWIGTYPE_p_std__mutex.getCPtr(xmldocmutex)); + } + + public static void set_analysis_info_from_n42(SWIGTYPE_p_rapidxml__xml_nodeT_char_t analysis_node, DetectorAnalysis analysis) { + SpecUtilsSwigJNI.set_analysis_info_from_n42(SWIGTYPE_p_rapidxml__xml_nodeT_char_t.getCPtr(analysis_node), DetectorAnalysis.getCPtr(analysis), analysis); + } + + public static double gamma_integral(Measurement hist, float lowenergy, float upperunergy) { + return SpecUtilsSwigJNI.gamma_integral(Measurement.getCPtr(hist), hist, lowenergy, upperunergy); + } + + public static String detectorTypeToString(DetectorType type) { + return SpecUtilsSwigJNI.detectorTypeToString(type.swigValue()); + } + + public static SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_t energy_cal_combine_channels(EnergyCalibration orig_cal, long num_channel_combine) { + return new SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_t(SpecUtilsSwigJNI.energy_cal_combine_channels(EnergyCalibration.getCPtr(orig_cal), orig_cal, num_channel_combine), true); + } + + public static FloatVector polynomial_binning(FloatVector coeffs, long nchannel, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t deviation_pairs) { + long cPtr = SpecUtilsSwigJNI.polynomial_binning(FloatVector.getCPtr(coeffs), coeffs, nchannel, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t.getCPtr(deviation_pairs)); + return (cPtr == 0) ? null : new FloatVector(cPtr, true); + } + + public static FloatVector fullrangefraction_binning(FloatVector coeffs, long nchannel, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t dev_pairs, boolean include_upper_energy) { + long cPtr = SpecUtilsSwigJNI.fullrangefraction_binning__SWIG_0(FloatVector.getCPtr(coeffs), coeffs, nchannel, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t.getCPtr(dev_pairs), include_upper_energy); + return (cPtr == 0) ? null : new FloatVector(cPtr, true); + } + + public static FloatVector fullrangefraction_binning(FloatVector coeffs, long nchannel, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t dev_pairs) { + long cPtr = SpecUtilsSwigJNI.fullrangefraction_binning__SWIG_1(FloatVector.getCPtr(coeffs), coeffs, nchannel, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t.getCPtr(dev_pairs)); + return (cPtr == 0) ? null : new FloatVector(cPtr, true); + } + + public static double fullrangefraction_energy(double channel_number, FloatVector coeffs, long nchannel, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t deviation_pairs) { + return SpecUtilsSwigJNI.fullrangefraction_energy(channel_number, FloatVector.getCPtr(coeffs), coeffs, nchannel, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t.getCPtr(deviation_pairs)); + } + + public static double polynomial_energy(double channel_number, FloatVector coeffs, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t deviation_pairs) { + return SpecUtilsSwigJNI.polynomial_energy(channel_number, FloatVector.getCPtr(coeffs), coeffs, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t.getCPtr(deviation_pairs)); + } + + public static double deviation_pair_correction(double polynomial_energy, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t dev_pairs) { + return SpecUtilsSwigJNI.deviation_pair_correction(polynomial_energy, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t.getCPtr(dev_pairs)); + } + + public static double correction_due_to_dev_pairs(double true_energy, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t dev_pairs) { + return SpecUtilsSwigJNI.correction_due_to_dev_pairs(true_energy, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t.getCPtr(dev_pairs)); + } + + public static FloatVector apply_deviation_pair(FloatVector binning, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t dev_pairs) { + long cPtr = SpecUtilsSwigJNI.apply_deviation_pair(FloatVector.getCPtr(binning), binning, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t.getCPtr(dev_pairs)); + return (cPtr == 0) ? null : new FloatVector(cPtr, true); + } + + public static FloatVector polynomial_coef_to_fullrangefraction(FloatVector coeffs, long nchannel) { + return new FloatVector(SpecUtilsSwigJNI.polynomial_coef_to_fullrangefraction(FloatVector.getCPtr(coeffs), coeffs, nchannel), true); + } + + public static FloatVector fullrangefraction_coef_to_polynomial(FloatVector coeffs, long nchannel) { + return new FloatVector(SpecUtilsSwigJNI.fullrangefraction_coef_to_polynomial(FloatVector.getCPtr(coeffs), coeffs, nchannel), true); + } + + public static FloatVector mid_channel_polynomial_to_fullrangeFraction(FloatVector coeffs, long nchannel) { + return new FloatVector(SpecUtilsSwigJNI.mid_channel_polynomial_to_fullrangeFraction(FloatVector.getCPtr(coeffs), coeffs, nchannel), true); + } + + public static boolean calibration_is_valid(EnergyCalType type, FloatVector eqn, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t devpairs, long nbin) { + return SpecUtilsSwigJNI.calibration_is_valid(type.swigValue(), FloatVector.getCPtr(eqn), eqn, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t.getCPtr(devpairs), nbin); + } + + public static FloatVector polynomial_cal_remove_first_channels(int num_channels_remove, FloatVector orig_coefs) { + return new FloatVector(SpecUtilsSwigJNI.polynomial_cal_remove_first_channels(num_channels_remove, FloatVector.getCPtr(orig_coefs), orig_coefs), true); + } + + public static double find_fullrangefraction_channel(double energy, FloatVector coeffs, long nchannel, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t deviation_pairs, double accuracy) { + return SpecUtilsSwigJNI.find_fullrangefraction_channel__SWIG_0(energy, FloatVector.getCPtr(coeffs), coeffs, nchannel, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t.getCPtr(deviation_pairs), accuracy); + } + + public static double find_fullrangefraction_channel(double energy, FloatVector coeffs, long nchannel, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t deviation_pairs) { + return SpecUtilsSwigJNI.find_fullrangefraction_channel__SWIG_1(energy, FloatVector.getCPtr(coeffs), coeffs, nchannel, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t.getCPtr(deviation_pairs)); + } + + public static double find_polynomial_channel(double energy, FloatVector coeffs, long nchannel, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t deviation_pairs, double accuracy) { + return SpecUtilsSwigJNI.find_polynomial_channel__SWIG_0(energy, FloatVector.getCPtr(coeffs), coeffs, nchannel, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t.getCPtr(deviation_pairs), accuracy); + } + + public static double find_polynomial_channel(double energy, FloatVector coeffs, long nchannel, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t deviation_pairs) { + return SpecUtilsSwigJNI.find_polynomial_channel__SWIG_1(energy, FloatVector.getCPtr(coeffs), coeffs, nchannel, SWIGTYPE_p_std__vectorT_std__pairT_float_float_t_t.getCPtr(deviation_pairs)); + } + + public static void rebin_by_lower_edge(FloatVector original_energies, FloatVector original_counts, FloatVector new_energies, FloatVector resulting_counts) { + SpecUtilsSwigJNI.rebin_by_lower_edge(FloatVector.getCPtr(original_energies), original_energies, FloatVector.getCPtr(original_counts), original_counts, FloatVector.getCPtr(new_energies), new_energies, FloatVector.getCPtr(resulting_counts), resulting_counts); + } + + public static SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_t energy_cal_from_CALp_file(SWIGTYPE_p_std__istream input, long num_channels, SWIGTYPE_p_std__string det_name) { + return new SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_t(SpecUtilsSwigJNI.energy_cal_from_CALp_file(SWIGTYPE_p_std__istream.getCPtr(input), num_channels, SWIGTYPE_p_std__string.getCPtr(det_name)), true); + } + + public static boolean write_CALp_file(SWIGTYPE_p_std__ostream output, SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_const_t cal, String detector_name) { + return SpecUtilsSwigJNI.write_CALp_file(SWIGTYPE_p_std__ostream.getCPtr(output), SWIGTYPE_p_std__shared_ptrT_SpecUtils__EnergyCalibration_const_t.getCPtr(cal), detector_name); + } + + public static SWIGTYPE_p_unsigned_char getD3_MIN_JS() { + long cPtr = SpecUtilsSwigJNI.D3_MIN_JS_get(); + return (cPtr == 0) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false); + } + + public static long getD3_MIN_JS_SIZE() { + return SpecUtilsSwigJNI.D3_MIN_JS_SIZE_get(); + } + + public static SWIGTYPE_p_unsigned_char getSPECTRUM_CHART_D3_JS() { + long cPtr = SpecUtilsSwigJNI.SPECTRUM_CHART_D3_JS_get(); + return (cPtr == 0) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false); + } + + public static long getSPECTRUM_CHART_D3_JS_SIZE() { + return SpecUtilsSwigJNI.SPECTRUM_CHART_D3_JS_SIZE_get(); + } + + public static SWIGTYPE_p_unsigned_char getSPECTRUM_CHART_D3_CSS() { + long cPtr = SpecUtilsSwigJNI.SPECTRUM_CHART_D3_CSS_get(); + return (cPtr == 0) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false); + } + + public static long getSPECTRUM_CHART_D3_CSS_SIZE() { + return SpecUtilsSwigJNI.SPECTRUM_CHART_D3_CSS_SIZE_get(); + } + + public static SWIGTYPE_p_unsigned_char getSPECTRUM_CHART_D3_STANDALONE_CSS() { + long cPtr = SpecUtilsSwigJNI.SPECTRUM_CHART_D3_STANDALONE_CSS_get(); + return (cPtr == 0) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false); + } + + public static long getSPECTRUM_CHART_D3_STANDALONE_CSS_SIZE() { + return SpecUtilsSwigJNI.SPECTRUM_CHART_D3_STANDALONE_CSS_SIZE_get(); + } + + public static boolean write_spectrum_data_js(SWIGTYPE_p_std__ostream ostr, Measurement meas, D3SpectrumOptions options, long specID, int backgroundID) { + return SpecUtilsSwigJNI.write_spectrum_data_js(SWIGTYPE_p_std__ostream.getCPtr(ostr), Measurement.getCPtr(meas), meas, D3SpectrumOptions.getCPtr(options), options, specID, backgroundID); + } + + public static boolean write_d3_html(SWIGTYPE_p_std__ostream ostr, SWIGTYPE_p_std__vectorT_std__pairT_SpecUtils__Measurement_const_p_D3SpectrumExport__D3SpectrumOptions_t_t measurements, D3SpectrumChartOptions options) { + return SpecUtilsSwigJNI.write_d3_html(SWIGTYPE_p_std__ostream.getCPtr(ostr), SWIGTYPE_p_std__vectorT_std__pairT_SpecUtils__Measurement_const_p_D3SpectrumExport__D3SpectrumOptions_t_t.getCPtr(measurements), D3SpectrumChartOptions.getCPtr(options), options); + } + + public static boolean write_html_page_header(SWIGTYPE_p_std__ostream ostr, String page_title) { + return SpecUtilsSwigJNI.write_html_page_header(SWIGTYPE_p_std__ostream.getCPtr(ostr), page_title); + } + + public static boolean write_js_for_chart(SWIGTYPE_p_std__ostream ostr, String div_name, String chart_title, String x_axis_title, String y_axis_title) { + return SpecUtilsSwigJNI.write_js_for_chart(SWIGTYPE_p_std__ostream.getCPtr(ostr), div_name, chart_title, x_axis_title, y_axis_title); + } + + public static boolean write_and_set_data_for_chart(SWIGTYPE_p_std__ostream ostr, String div_name, SWIGTYPE_p_std__vectorT_std__pairT_SpecUtils__Measurement_const_p_D3SpectrumExport__D3SpectrumOptions_t_t measurements) { + return SpecUtilsSwigJNI.write_and_set_data_for_chart(SWIGTYPE_p_std__ostream.getCPtr(ostr), div_name, SWIGTYPE_p_std__vectorT_std__pairT_SpecUtils__Measurement_const_p_D3SpectrumExport__D3SpectrumOptions_t_t.getCPtr(measurements)); + } + + public static boolean write_set_options_for_chart(SWIGTYPE_p_std__ostream ostr, String div_name, D3SpectrumChartOptions options) { + return SpecUtilsSwigJNI.write_set_options_for_chart(SWIGTYPE_p_std__ostream.getCPtr(ostr), div_name, D3SpectrumChartOptions.getCPtr(options), options); + } + + public static boolean write_html_display_options_for_chart(SWIGTYPE_p_std__ostream ostr, String div_name, D3SpectrumChartOptions options) { + return SpecUtilsSwigJNI.write_html_display_options_for_chart(SWIGTYPE_p_std__ostream.getCPtr(ostr), div_name, D3SpectrumChartOptions.getCPtr(options), options); + } + + public static SWIGTYPE_p_unsigned_char d3_js() { + long cPtr = SpecUtilsSwigJNI.d3_js(); + return (cPtr == 0) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false); + } + + public static SWIGTYPE_p_unsigned_char spectrum_chart_d3_js() { + long cPtr = SpecUtilsSwigJNI.spectrum_chart_d3_js(); + return (cPtr == 0) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false); + } + + public static SWIGTYPE_p_unsigned_char spectrum_char_d3_css() { + long cPtr = SpecUtilsSwigJNI.spectrum_char_d3_css(); + return (cPtr == 0) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false); + } + + public static SWIGTYPE_p_unsigned_char spectrum_chart_d3_standalone_css() { + long cPtr = SpecUtilsSwigJNI.spectrum_chart_d3_standalone_css(); + return (cPtr == 0) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false); + } + + public static String spectrum_chart_setup_js() { + return SpecUtilsSwigJNI.spectrum_chart_setup_js(); + } + +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SpecUtilsSwigConstants.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SpecUtilsSwigConstants.java new file mode 100644 index 00000000..c0c0e942 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SpecUtilsSwigConstants.java @@ -0,0 +1,26 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public interface SpecUtilsSwigConstants { + public final static int PERFORM_DEVELOPER_CHECKS = SpecUtilsSwigJNI.PERFORM_DEVELOPER_CHECKS_get(); + public final static int SpecUtils_ENABLE_D3_CHART = SpecUtilsSwigJNI.SpecUtils_ENABLE_D3_CHART_get(); + public final static int SpecUtils_ENABLE_URI_SPECTRA = SpecUtilsSwigJNI.SpecUtils_ENABLE_URI_SPECTRA_get(); + public final static int SpecUtils_USE_WT_THREADPOOL = SpecUtilsSwigJNI.SpecUtils_USE_WT_THREADPOOL_get(); + public final static int SpecUtils_USING_NO_THREADING = SpecUtilsSwigJNI.SpecUtils_USING_NO_THREADING_get(); + public final static int SpecUtils_D3_SUPPORT_FILE_STATIC = SpecUtilsSwigJNI.SpecUtils_D3_SUPPORT_FILE_STATIC_get(); + public final static int SpecUtils_INJA_TEMPLATES = SpecUtilsSwigJNI.SpecUtils_INJA_TEMPLATES_get(); + public final static int SpecUtils_BUILD_FUZZING_TESTS = SpecUtilsSwigJNI.SpecUtils_BUILD_FUZZING_TESTS_get(); + public final static int SpecUtils_PYTHON_BINDINGS = SpecUtilsSwigJNI.SpecUtils_PYTHON_BINDINGS_get(); + public final static int SpecUtils_JAVA_SWIG = SpecUtilsSwigJNI.SpecUtils_JAVA_SWIG_get(); + public final static int SpecUtils_USE_SIMD = SpecUtilsSwigJNI.SpecUtils_USE_SIMD_get(); + public final static int SpecUtils_ENABLE_EQUALITY_CHECKS = SpecUtilsSwigJNI.SpecUtils_ENABLE_EQUALITY_CHECKS_get(); + public final static int SpecUtils_USE_FROM_CHARS = SpecUtilsSwigJNI.SpecUtils_USE_FROM_CHARS_get(); + public final static int SpecFile_2012N42_VERSION = SpecUtilsSwigJNI.SpecFile_2012N42_VERSION_get(); +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SpecUtilsSwigJNI.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SpecUtilsSwigJNI.java new file mode 100644 index 00000000..7748ed68 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SpecUtilsSwigJNI.java @@ -0,0 +1,532 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class SpecUtilsSwigJNI { + public final static native long new_StringVector__SWIG_0(); + public final static native long new_StringVector__SWIG_1(long jarg1, StringVector jarg1_); + public final static native boolean StringVector_isEmpty(long jarg1, StringVector jarg1_); + public final static native void StringVector_clear(long jarg1, StringVector jarg1_); + public final static native long new_StringVector__SWIG_2(int jarg1, String jarg2); + public final static native int StringVector_doCapacity(long jarg1, StringVector jarg1_); + public final static native void StringVector_doReserve(long jarg1, StringVector jarg1_, int jarg2); + public final static native int StringVector_doSize(long jarg1, StringVector jarg1_); + public final static native void StringVector_doAdd__SWIG_0(long jarg1, StringVector jarg1_, String jarg2); + public final static native void StringVector_doAdd__SWIG_1(long jarg1, StringVector jarg1_, int jarg2, String jarg3); + public final static native String StringVector_doRemove(long jarg1, StringVector jarg1_, int jarg2); + public final static native String StringVector_doGet(long jarg1, StringVector jarg1_, int jarg2); + public final static native String StringVector_doSet(long jarg1, StringVector jarg1_, int jarg2, String jarg3); + public final static native void StringVector_doRemoveRange(long jarg1, StringVector jarg1_, int jarg2, int jarg3); + public final static native void delete_StringVector(long jarg1); + public final static native long new_IntVector__SWIG_0(); + public final static native long new_IntVector__SWIG_1(long jarg1, IntVector jarg1_); + public final static native boolean IntVector_isEmpty(long jarg1, IntVector jarg1_); + public final static native void IntVector_clear(long jarg1, IntVector jarg1_); + public final static native long new_IntVector__SWIG_2(int jarg1, int jarg2); + public final static native int IntVector_doCapacity(long jarg1, IntVector jarg1_); + public final static native void IntVector_doReserve(long jarg1, IntVector jarg1_, int jarg2); + public final static native int IntVector_doSize(long jarg1, IntVector jarg1_); + public final static native void IntVector_doAdd__SWIG_0(long jarg1, IntVector jarg1_, int jarg2); + public final static native void IntVector_doAdd__SWIG_1(long jarg1, IntVector jarg1_, int jarg2, int jarg3); + public final static native int IntVector_doRemove(long jarg1, IntVector jarg1_, int jarg2); + public final static native int IntVector_doGet(long jarg1, IntVector jarg1_, int jarg2); + public final static native int IntVector_doSet(long jarg1, IntVector jarg1_, int jarg2, int jarg3); + public final static native void IntVector_doRemoveRange(long jarg1, IntVector jarg1_, int jarg2, int jarg3); + public final static native void delete_IntVector(long jarg1); + public final static native long new_FloatVector__SWIG_0(); + public final static native long new_FloatVector__SWIG_1(long jarg1, FloatVector jarg1_); + public final static native boolean FloatVector_isEmpty(long jarg1, FloatVector jarg1_); + public final static native void FloatVector_clear(long jarg1, FloatVector jarg1_); + public final static native long new_FloatVector__SWIG_2(int jarg1, float jarg2); + public final static native int FloatVector_doCapacity(long jarg1, FloatVector jarg1_); + public final static native void FloatVector_doReserve(long jarg1, FloatVector jarg1_, int jarg2); + public final static native int FloatVector_doSize(long jarg1, FloatVector jarg1_); + public final static native void FloatVector_doAdd__SWIG_0(long jarg1, FloatVector jarg1_, float jarg2); + public final static native void FloatVector_doAdd__SWIG_1(long jarg1, FloatVector jarg1_, int jarg2, float jarg3); + public final static native float FloatVector_doRemove(long jarg1, FloatVector jarg1_, int jarg2); + public final static native float FloatVector_doGet(long jarg1, FloatVector jarg1_, int jarg2); + public final static native float FloatVector_doSet(long jarg1, FloatVector jarg1_, int jarg2, float jarg3); + public final static native void FloatVector_doRemoveRange(long jarg1, FloatVector jarg1_, int jarg2, int jarg3); + public final static native void delete_FloatVector(long jarg1); + public final static native long openFile(String jarg1); + public final static native void closeFile(long jarg1); + public final static native int PERFORM_DEVELOPER_CHECKS_get(); + public final static native int SpecUtils_ENABLE_D3_CHART_get(); + public final static native int SpecUtils_ENABLE_URI_SPECTRA_get(); + public final static native int SpecUtils_USE_WT_THREADPOOL_get(); + public final static native int SpecUtils_USING_NO_THREADING_get(); + public final static native int SpecUtils_D3_SUPPORT_FILE_STATIC_get(); + public final static native int SpecUtils_INJA_TEMPLATES_get(); + public final static native int SpecUtils_BUILD_FUZZING_TESTS_get(); + public final static native int SpecUtils_PYTHON_BINDINGS_get(); + public final static native int SpecUtils_JAVA_SWIG_get(); + public final static native int SpecUtils_USE_SIMD_get(); + public final static native int SpecUtils_ENABLE_EQUALITY_CHECKS_get(); + public final static native int SpecUtils_USE_FROM_CHARS_get(); + public final static native String descriptionText__SWIG_0(int jarg1); + public final static native int spectrumTypeFromDescription(String jarg1); + public final static native String suggestedNameEnding(int jarg1); + public final static native String descriptionText__SWIG_1(int jarg1); + public final static native boolean is_candidate_n42_file__SWIG_0(String jarg1); + public final static native boolean is_candidate_n42_file__SWIG_1(String jarg1, String jarg2); + public final static native String convert_n42_utf16_xml_to_utf8(String jarg1, String jarg2); + public final static native void add_analysis_results_to_2012_N42(long jarg1, DetectorAnalysis jarg1_, long jarg2, long jarg3); + public final static native void set_analysis_info_from_n42(long jarg1, long jarg2, DetectorAnalysis jarg2_); + public final static native double gamma_integral(long jarg1, Measurement jarg1_, float jarg2, float jarg3); + public final static native String detectorTypeToString(int jarg1); + public final static native long new_Measurement(); + public final static native long Measurement_operatorEqual(long jarg1, Measurement jarg1_, long jarg2, Measurement jarg2_); + public final static native long Measurement_memmorysize(long jarg1, Measurement jarg1_); + public final static native float Measurement_live_time(long jarg1, Measurement jarg1_); + public final static native float Measurement_real_time(long jarg1, Measurement jarg1_); + public final static native boolean Measurement_contained_neutron(long jarg1, Measurement jarg1_); + public final static native int Measurement_sample_number(long jarg1, Measurement jarg1_); + public final static native String Measurement_title(long jarg1, Measurement jarg1_); + public final static native int Measurement_occupied(long jarg1, Measurement jarg1_); + public final static native double Measurement_gamma_count_sum(long jarg1, Measurement jarg1_); + public final static native float Measurement_neutron_live_time(long jarg1, Measurement jarg1_); + public final static native double Measurement_neutron_counts_sum(long jarg1, Measurement jarg1_); + public final static native float Measurement_speed(long jarg1, Measurement jarg1_); + public final static native float Measurement_dx(long jarg1, Measurement jarg1_); + public final static native float Measurement_dy(long jarg1, Measurement jarg1_); + public final static native double Measurement_latitude(long jarg1, Measurement jarg1_); + public final static native double Measurement_longitude(long jarg1, Measurement jarg1_); + public final static native boolean Measurement_has_gps_info(long jarg1, Measurement jarg1_); + public final static native float Measurement_dose_rate(long jarg1, Measurement jarg1_); + public final static native float Measurement_exposure_rate(long jarg1, Measurement jarg1_); + public final static native long Measurement_position_time(long jarg1, Measurement jarg1_); + public final static native String Measurement_detector_name(long jarg1, Measurement jarg1_); + public final static native int Measurement_detector_number(long jarg1, Measurement jarg1_); + public final static native String Measurement_detector_type(long jarg1, Measurement jarg1_); + public final static native int Measurement_quality_status(long jarg1, Measurement jarg1_); + public final static native int Measurement_source_type(long jarg1, Measurement jarg1_); + public final static native long Measurement_remarks(long jarg1, Measurement jarg1_); + public final static native long Measurement_parse_warnings(long jarg1, Measurement jarg1_); + public final static native long Measurement_start_time(long jarg1, Measurement jarg1_); + public final static native long Measurement_start_time_copy(long jarg1, Measurement jarg1_); + public final static native int Measurement_energy_calibration_model(long jarg1, Measurement jarg1_); + public final static native long Measurement_calibration_coeffs(long jarg1, Measurement jarg1_); + public final static native long Measurement_deviation_pairs(long jarg1, Measurement jarg1_); + public final static native long Measurement_energy_calibration(long jarg1, Measurement jarg1_); + public final static native long Measurement_channel_energies(long jarg1, Measurement jarg1_); + public final static native long Measurement_gamma_counts(long jarg1, Measurement jarg1_); + public final static native long Measurement_neutron_counts(long jarg1, Measurement jarg1_); + public final static native long Measurement_location_state(long jarg1, Measurement jarg1_); + public final static native void Measurement_set_title(long jarg1, Measurement jarg1_, String jarg2); + public final static native void Measurement_set_start_time(long jarg1, Measurement jarg1_, long jarg2); + public final static native void Measurement_set_remarks(long jarg1, Measurement jarg1_, long jarg2, StringVector jarg2_); + public final static native void Measurement_set_parse_warnings(long jarg1, Measurement jarg1_, long jarg2, StringVector jarg2_); + public final static native void Measurement_set_source_type(long jarg1, Measurement jarg1_, int jarg2); + public final static native void Measurement_set_position(long jarg1, Measurement jarg1_, double jarg2, double jarg3, long jarg4); + public final static native void Measurement_set_sample_number(long jarg1, Measurement jarg1_, int jarg2); + public final static native void Measurement_set_occupancy_status(long jarg1, Measurement jarg1_, int jarg2); + public final static native void Measurement_set_detector_name(long jarg1, Measurement jarg1_, String jarg2); + public final static native void Measurement_set_detector_number(long jarg1, Measurement jarg1_, int jarg2); + public final static native void Measurement_set_gamma_counts(long jarg1, Measurement jarg1_, long jarg2, FloatVector jarg2_, float jarg3, float jarg4); + public final static native void Measurement_set_neutron_counts(long jarg1, Measurement jarg1_, long jarg2, FloatVector jarg2_, float jarg3); + public final static native long Measurement_num_gamma_channels(long jarg1, Measurement jarg1_); + public final static native long Measurement_find_gamma_channel(long jarg1, Measurement jarg1_, float jarg2); + public final static native float Measurement_gamma_channel_content(long jarg1, Measurement jarg1_, long jarg2); + public final static native float Measurement_gamma_channel_lower(long jarg1, Measurement jarg1_, long jarg2); + public final static native float Measurement_gamma_channel_center(long jarg1, Measurement jarg1_, long jarg2); + public final static native float Measurement_gamma_channel_upper(long jarg1, Measurement jarg1_, long jarg2); + public final static native float Measurement_gamma_channel_width(long jarg1, Measurement jarg1_, long jarg2); + public final static native double Measurement_gamma_integral(long jarg1, Measurement jarg1_, float jarg2, float jarg3); + public final static native double Measurement_gamma_channels_sum(long jarg1, Measurement jarg1_, long jarg2, long jarg3); + public final static native long Measurement_gamma_channel_energies(long jarg1, Measurement jarg1_); + public final static native long Measurement_gamma_channel_contents(long jarg1, Measurement jarg1_); + public final static native float Measurement_gamma_energy_min(long jarg1, Measurement jarg1_); + public final static native float Measurement_gamma_energy_max(long jarg1, Measurement jarg1_); + public final static native int Measurement_DerivedDataProperties_IsDerived_get(); + public final static native int Measurement_DerivedDataProperties_ItemOfInterestSum_get(); + public final static native int Measurement_DerivedDataProperties_UsedForAnalysis_get(); + public final static native int Measurement_DerivedDataProperties_ProcessedFurther_get(); + public final static native int Measurement_DerivedDataProperties_BackgroundSubtracted_get(); + public final static native int Measurement_DerivedDataProperties_IsBackground_get(); + public final static native long Measurement_derived_data_properties(long jarg1, Measurement jarg1_); + public final static native boolean Measurement_write_2006_N42_xml(long jarg1, Measurement jarg1_, long jarg2); + public final static native boolean Measurement_write_csv(long jarg1, Measurement jarg1_, long jarg2); + public final static native boolean Measurement_write_txt(long jarg1, Measurement jarg1_, long jarg2); + public final static native void Measurement_reset(long jarg1, Measurement jarg1_); + public final static native void Measurement_combine_gamma_channels(long jarg1, Measurement jarg1_, long jarg2); + public final static native void Measurement_truncate_gamma_channels(long jarg1, Measurement jarg1_, long jarg2, long jarg3, boolean jarg4); + public final static native void Measurement_rebin(long jarg1, Measurement jarg1_, long jarg2); + public final static native void Measurement_set_energy_calibration(long jarg1, Measurement jarg1_, long jarg2); + public final static native void Measurement_set_info_from_2006_N42_spectrum_node(long jarg1, Measurement jarg1_, long jarg2); + public final static native void delete_Measurement(long jarg1); + public final static native long new_SpecFile__SWIG_0(); + public final static native long new_SpecFile__SWIG_1(long jarg1, SpecFile jarg1_); + public final static native void delete_SpecFile(long jarg1); + public final static native long SpecFile_operatorEqual(long jarg1, SpecFile jarg1_, long jarg2, SpecFile jarg2_); + public final static native boolean SpecFile_load_file(long jarg1, SpecFile jarg1_, String jarg2, int jarg3, String jarg4); + public final static native long SpecFile_parse_warnings(long jarg1, SpecFile jarg1_); + public final static native boolean SpecFile_modified(long jarg1, SpecFile jarg1_); + public final static native void SpecFile_reset_modified(long jarg1, SpecFile jarg1_); + public final static native boolean SpecFile_modified_since_decode(long jarg1, SpecFile jarg1_); + public final static native void SpecFile_reset_modified_since_decode(long jarg1, SpecFile jarg1_); + public final static native float SpecFile_gamma_live_time(long jarg1, SpecFile jarg1_); + public final static native float SpecFile_gamma_real_time(long jarg1, SpecFile jarg1_); + public final static native double SpecFile_gamma_count_sum(long jarg1, SpecFile jarg1_); + public final static native double SpecFile_neutron_counts_sum(long jarg1, SpecFile jarg1_); + public final static native String SpecFile_filename(long jarg1, SpecFile jarg1_); + public final static native long SpecFile_detector_names(long jarg1, SpecFile jarg1_); + public final static native long SpecFile_detector_numbers(long jarg1, SpecFile jarg1_); + public final static native long SpecFile_gamma_detector_names(long jarg1, SpecFile jarg1_); + public final static native long SpecFile_neutron_detector_names(long jarg1, SpecFile jarg1_); + public final static native String SpecFile_uuid(long jarg1, SpecFile jarg1_); + public final static native long SpecFile_remarks(long jarg1, SpecFile jarg1_); + public final static native int SpecFile_lane_number(long jarg1, SpecFile jarg1_); + public final static native String SpecFile_measurement_location_name(long jarg1, SpecFile jarg1_); + public final static native String SpecFile_inspection(long jarg1, SpecFile jarg1_); + public final static native String SpecFile_measurement_operator(long jarg1, SpecFile jarg1_); + public final static native long SpecFile_sample_numbers(long jarg1, SpecFile jarg1_); + public final static native long SpecFile_num_measurements(long jarg1, SpecFile jarg1_); + public final static native int SpecFile_detector_type(long jarg1, SpecFile jarg1_); + public final static native String SpecFile_instrument_type(long jarg1, SpecFile jarg1_); + public final static native String SpecFile_manufacturer(long jarg1, SpecFile jarg1_); + public final static native String SpecFile_instrument_model(long jarg1, SpecFile jarg1_); + public final static native String SpecFile_instrument_id(long jarg1, SpecFile jarg1_); + public final static native long SpecFile_measurements(long jarg1, SpecFile jarg1_); + public final static native long SpecFile_measurement__SWIG_0(long jarg1, SpecFile jarg1_, long jarg2); + public final static native long SpecFile_detectors_analysis(long jarg1, SpecFile jarg1_); + public final static native long SpecFile_multimedia_data(long jarg1, SpecFile jarg1_); + public final static native boolean SpecFile_has_gps_info(long jarg1, SpecFile jarg1_); + public final static native double SpecFile_mean_latitude(long jarg1, SpecFile jarg1_); + public final static native double SpecFile_mean_longitude(long jarg1, SpecFile jarg1_); + public final static native boolean SpecFile_passthrough(long jarg1, SpecFile jarg1_); + public final static native boolean SpecFile_contains_derived_data(long jarg1, SpecFile jarg1_); + public final static native boolean SpecFile_contains_non_derived_data(long jarg1, SpecFile jarg1_); + public final static native void SpecFile_set_filename(long jarg1, SpecFile jarg1_, String jarg2); + public final static native void SpecFile_set_remarks__SWIG_0(long jarg1, SpecFile jarg1_, long jarg2, StringVector jarg2_); + public final static native void SpecFile_add_remark(long jarg1, SpecFile jarg1_, String jarg2); + public final static native void SpecFile_set_parse_warnings(long jarg1, SpecFile jarg1_, long jarg2, StringVector jarg2_); + public final static native void SpecFile_set_uuid(long jarg1, SpecFile jarg1_, String jarg2); + public final static native void SpecFile_set_lane_number(long jarg1, SpecFile jarg1_, int jarg2); + public final static native void SpecFile_set_measurement_location_name(long jarg1, SpecFile jarg1_, String jarg2); + public final static native void SpecFile_set_inspection(long jarg1, SpecFile jarg1_, String jarg2); + public final static native void SpecFile_set_instrument_type(long jarg1, SpecFile jarg1_, String jarg2); + public final static native void SpecFile_set_detector_type(long jarg1, SpecFile jarg1_, int jarg2); + public final static native void SpecFile_set_manufacturer(long jarg1, SpecFile jarg1_, String jarg2); + public final static native void SpecFile_set_instrument_model(long jarg1, SpecFile jarg1_, String jarg2); + public final static native void SpecFile_set_instrument_id(long jarg1, SpecFile jarg1_, String jarg2); + public final static native void SpecFile_set_live_time(long jarg1, SpecFile jarg1_, float jarg2, long jarg3, Measurement jarg3_); + public final static native void SpecFile_set_real_time(long jarg1, SpecFile jarg1_, float jarg2, long jarg3, Measurement jarg3_); + public final static native void SpecFile_set_start_time(long jarg1, SpecFile jarg1_, long jarg2, long jarg3, Measurement jarg3_); + public final static native void SpecFile_set_remarks__SWIG_1(long jarg1, SpecFile jarg1_, long jarg2, StringVector jarg2_, long jarg3, Measurement jarg3_); + public final static native void SpecFile_set_source_type(long jarg1, SpecFile jarg1_, int jarg2, long jarg3, Measurement jarg3_); + public final static native void SpecFile_set_position(long jarg1, SpecFile jarg1_, double jarg2, double jarg3, long jarg4, long jarg5, Measurement jarg5_); + public final static native void SpecFile_set_title(long jarg1, SpecFile jarg1_, String jarg2, long jarg3, Measurement jarg3_); + public final static native void SpecFile_set_contained_neutrons(long jarg1, SpecFile jarg1_, boolean jarg2, float jarg3, long jarg4, Measurement jarg4_, float jarg5); + public final static native void SpecFile_set_detectors_analysis(long jarg1, SpecFile jarg1_, long jarg2, DetectorAnalysis jarg2_); + public final static native void SpecFile_change_detector_name(long jarg1, SpecFile jarg1_, String jarg2, String jarg3); + public final static native void SpecFile_change_sample_numbers(long jarg1, SpecFile jarg1_, long jarg2); + public final static native void SpecFile_add_measurement(long jarg1, SpecFile jarg1_, long jarg2, Measurement jarg2_, boolean jarg3); + public final static native void SpecFile_remove_measurement(long jarg1, SpecFile jarg1_, long jarg2, Measurement jarg2_, boolean jarg3); + public final static native void SpecFile_remove_measurements(long jarg1, SpecFile jarg1_, long jarg2); + public final static native void SpecFile_clear_multimedia_data(long jarg1, SpecFile jarg1_); + public final static native void SpecFile_add_multimedia_data(long jarg1, SpecFile jarg1_, long jarg2, MultimediaData jarg2_); + public final static native void SpecFile_set_multimedia_data(long jarg1, SpecFile jarg1_, long jarg2); + public final static native long SpecFile_combine_gamma_channels__SWIG_0(long jarg1, SpecFile jarg1_, long jarg2, long jarg3); + public final static native void SpecFile_combine_gamma_channels__SWIG_1(long jarg1, SpecFile jarg1_, long jarg2, long jarg3, Measurement jarg3_); + public final static native long SpecFile_truncate_gamma_channels__SWIG_0(long jarg1, SpecFile jarg1_, long jarg2, long jarg3, long jarg4, boolean jarg5); + public final static native void SpecFile_truncate_gamma_channels__SWIG_1(long jarg1, SpecFile jarg1_, long jarg2, long jarg3, boolean jarg4, long jarg5, Measurement jarg5_); + public final static native int SpecFile_occupancy_number_from_remarks(long jarg1, SpecFile jarg1_); + public final static native long SpecFile_sample_measurements(long jarg1, SpecFile jarg1_, int jarg2); + public final static native long SpecFile_measurement__SWIG_1(long jarg1, SpecFile jarg1_, int jarg2, String jarg3); + public final static native long SpecFile_measurement__SWIG_2(long jarg1, SpecFile jarg1_, int jarg2, int jarg3); + public final static native long SpecFile_suggested_sum_energy_calibration(long jarg1, SpecFile jarg1_, long jarg2, long jarg3, StringVector jarg3_); + public final static native long SpecFile_sum_measurements(long jarg1, SpecFile jarg1_, long jarg2, long jarg3, StringVector jarg3_, long jarg4); + public final static native long SpecFile_memmorysize(long jarg1, SpecFile jarg1_); + public final static native long SpecFile_gamma_channel_counts(long jarg1, SpecFile jarg1_); + public final static native long SpecFile_num_gamma_channels(long jarg1, SpecFile jarg1_); + public final static native long SpecFile_keep_n_bin_spectra_only(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_contained_neutron(long jarg1, SpecFile jarg1_); + public final static native long SpecFile_energy_cal_variants(long jarg1, SpecFile jarg1_); + public final static native long SpecFile_keep_energy_cal_variants(long jarg1, SpecFile jarg1_, long jarg2); + public final static native long SpecFile_keep_derived_data_variant(long jarg1, SpecFile jarg1_, int jarg2); + public final static native long SpecFile_remove_detectors_data(long jarg1, SpecFile jarg1_, long jarg2); + public final static native long SpecFile_remove_neutron_measurements(long jarg1, SpecFile jarg1_); + public final static native int SpecFile_background_sample_number(long jarg1, SpecFile jarg1_); + public final static native String SpecFile_generate_psuedo_uuid(long jarg1, SpecFile jarg1_); + public final static native void SpecFile_reset(long jarg1, SpecFile jarg1_); + public final static native boolean SpecFile_load_N42_file(long jarg1, SpecFile jarg1_, String jarg2); + public final static native boolean SpecFile_load_pcf_file(long jarg1, SpecFile jarg1_, String jarg2); + public final static native boolean SpecFile_load_spc_file(long jarg1, SpecFile jarg1_, String jarg2); + public final static native boolean SpecFile_load_chn_file(long jarg1, SpecFile jarg1_, String jarg2); + public final static native boolean SpecFile_load_iaea_file(long jarg1, SpecFile jarg1_, String jarg2); + public final static native boolean SpecFile_load_binary_exploranium_file(long jarg1, SpecFile jarg1_, String jarg2); + public final static native boolean SpecFile_load_micro_raider_file(long jarg1, SpecFile jarg1_, String jarg2); + public final static native boolean SpecFile_load_txt_or_csv_file(long jarg1, SpecFile jarg1_, String jarg2); + public final static native boolean SpecFile_load_cnf_file(long jarg1, SpecFile jarg1_, String jarg2); + public final static native boolean SpecFile_load_tracs_mps_file(long jarg1, SpecFile jarg1_, String jarg2); + public final static native boolean SpecFile_load_aram_file(long jarg1, SpecFile jarg1_, String jarg2); + public final static native boolean SpecFile_load_spectroscopic_daily_file(long jarg1, SpecFile jarg1_, String jarg2); + public final static native boolean SpecFile_load_amptek_file(long jarg1, SpecFile jarg1_, String jarg2); + public final static native boolean SpecFile_load_ortec_listmode_file(long jarg1, SpecFile jarg1_, String jarg2); + public final static native boolean SpecFile_load_lsrm_spe_file(long jarg1, SpecFile jarg1_, String jarg2); + public final static native boolean SpecFile_load_tka_file(long jarg1, SpecFile jarg1_, String jarg2); + public final static native boolean SpecFile_load_multiact_file(long jarg1, SpecFile jarg1_, String jarg2); + public final static native boolean SpecFile_load_phd_file(long jarg1, SpecFile jarg1_, String jarg2); + public final static native boolean SpecFile_load_lzs_file(long jarg1, SpecFile jarg1_, String jarg2); + public final static native boolean SpecFile_load_radiacode_file(long jarg1, SpecFile jarg1_, String jarg2); + public final static native boolean SpecFile_load_xml_scan_data_file(long jarg1, SpecFile jarg1_, String jarg2); + public final static native boolean SpecFile_load_json_file(long jarg1, SpecFile jarg1_, String jarg2); + public final static native boolean SpecFile_load_caen_gxml_file(long jarg1, SpecFile jarg1_, String jarg2); + public final static native boolean SpecFile_load_from_N42(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_load_N42_from_data__SWIG_0(long jarg1, SpecFile jarg1_, String jarg2); + public final static native boolean SpecFile_load_N42_from_data__SWIG_1(long jarg1, SpecFile jarg1_, String jarg2, String jarg3); + public final static native boolean SpecFile_load_from_iaea_spc(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_load_from_binary_spc(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_load_from_N42_document(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_load_from_micro_raider_from_data(long jarg1, SpecFile jarg1_, String jarg2); + public final static native boolean SpecFile_load_from_binary_exploranium(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_load_from_pcf(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_load_from_txt_or_csv(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_load_from_Gr135_txt(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_load_from_spectroscopic_daily_file(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_load_from_srpm210_csv(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_load_from_D3S_raw(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_load_from_amptek_mca(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_load_from_ortec_listmode(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_load_from_lsrm_spe(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_load_from_tka(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_load_from_multiact(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_load_from_phd(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_load_from_lzs(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_load_from_radiacode(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_load_from_radiacode_spectrogram(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_load_from_xml_scan_data(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_load_from_iaea(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_load_from_chn(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_load_from_cnf(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_load_from_tracs_mps(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_load_from_aram(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_load_from_json(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_load_from_caen_gxml(long jarg1, SpecFile jarg1_, long jarg2); + public final static native int SpecFile_RebinToCommonBinning_get(); + public final static native int SpecFile_DontChangeOrReorderSamples_get(); + public final static native int SpecFile_ReorderSamplesByTime_get(); + public final static native int SpecFile_StandardCleanup_get(); + public final static native void SpecFile_cleanup_after_load__SWIG_0(long jarg1, SpecFile jarg1_, long jarg2); + public final static native void SpecFile_cleanup_after_load__SWIG_1(long jarg1, SpecFile jarg1_); + public final static native void SpecFile_recalc_total_counts(long jarg1, SpecFile jarg1_); + public final static native void SpecFile_merge_neutron_meas_into_gamma_meas(long jarg1, SpecFile jarg1_); + public final static native void SpecFile_rebin_measurement(long jarg1, SpecFile jarg1_, long jarg2, long jarg3, Measurement jarg3_); + public final static native void SpecFile_rebin_all_measurements(long jarg1, SpecFile jarg1_, long jarg2); + public final static native void SpecFile_set_energy_calibration__SWIG_0(long jarg1, SpecFile jarg1_, long jarg2, long jarg3, Measurement jarg3_); + public final static native long SpecFile_set_energy_calibration__SWIG_1(long jarg1, SpecFile jarg1_, long jarg2, long jarg3, long jarg4, StringVector jarg4_); + public final static native void SpecFile_set_energy_calibration_from_CALp_file(long jarg1, SpecFile jarg1_, long jarg2); + public final static native long SpecFile_detector_names_to_numbers(long jarg1, SpecFile jarg1_, long jarg2, StringVector jarg2_); + public final static native void SpecFile_write_to_file__SWIG_0(long jarg1, SpecFile jarg1_, String jarg2, int jarg3); + public final static native void SpecFile_write_to_file__SWIG_1(long jarg1, SpecFile jarg1_, String jarg2, long jarg3, long jarg4, int jarg5); + public final static native void SpecFile_write_to_file__SWIG_2(long jarg1, SpecFile jarg1_, String jarg2, long jarg3, IntVector jarg3_, long jarg4, IntVector jarg4_, int jarg5); + public final static native void SpecFile_write_to_file__SWIG_3(long jarg1, SpecFile jarg1_, String jarg2, long jarg3, long jarg4, StringVector jarg4_, int jarg5); + public final static native void SpecFile_write__SWIG_0(long jarg1, SpecFile jarg1_, long jarg2, long jarg3, long jarg4, int jarg5); + public final static native void SpecFile_write__SWIG_1(long jarg1, SpecFile jarg1_, long jarg2, long jarg3, long jarg4, StringVector jarg4_, int jarg5); + public final static native boolean SpecFile_write_pcf(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_write_2006_N42(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_write_csv(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_write_txt(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_write_integer_chn__SWIG_0(long jarg1, SpecFile jarg1_, long jarg2, long jarg3, long jarg4); + public final static native boolean SpecFile_write_integer_chn__SWIG_1(long jarg1, SpecFile jarg1_, long jarg2, long jarg3, long jarg4, StringVector jarg4_); + public final static native boolean SpecFile_write_binary_spc(long jarg1, SpecFile jarg1_, long jarg2, int jarg3, long jarg4, long jarg5); + public final static native boolean SpecFile_write_ascii_spc(long jarg1, SpecFile jarg1_, long jarg2, long jarg3, long jarg4); + public final static native boolean SpecFile_write_binary_exploranium_gr130v0(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_write_binary_exploranium_gr135v2(long jarg1, SpecFile jarg1_, long jarg2); + public final static native boolean SpecFile_write_iaea_spe(long jarg1, SpecFile jarg1_, long jarg2, long jarg3, long jarg4); + public final static native boolean SpecFile_write_cnf(long jarg1, SpecFile jarg1_, long jarg2, long jarg3, long jarg4); + public final static native boolean SpecFile_write_tka(long jarg1, SpecFile jarg1_, long jarg2, long jarg3, long jarg4); + public final static native boolean SpecFile_write_d3_html(long jarg1, SpecFile jarg1_, long jarg2, long jarg3, D3SpectrumChartOptions jarg3_, long jarg4, long jarg5, StringVector jarg5_); + public final static native int SpecFile_2012N42_VERSION_get(); + public final static native long SpecFile_create_2012_N42_xml(long jarg1, SpecFile jarg1_); + public final static native boolean SpecFile_write_2012_N42(long jarg1, SpecFile jarg1_, long jarg2); + public final static native long SpecFile_mutex(long jarg1, SpecFile jarg1_); + public final static native void DetectorAnalysisResult_remark__set(long jarg1, DetectorAnalysisResult jarg1_, String jarg2); + public final static native String DetectorAnalysisResult_remark__get(long jarg1, DetectorAnalysisResult jarg1_); + public final static native void DetectorAnalysisResult_nuclide__set(long jarg1, DetectorAnalysisResult jarg1_, String jarg2); + public final static native String DetectorAnalysisResult_nuclide__get(long jarg1, DetectorAnalysisResult jarg1_); + public final static native void DetectorAnalysisResult_activity__set(long jarg1, DetectorAnalysisResult jarg1_, float jarg2); + public final static native float DetectorAnalysisResult_activity__get(long jarg1, DetectorAnalysisResult jarg1_); + public final static native void DetectorAnalysisResult_nuclide_type__set(long jarg1, DetectorAnalysisResult jarg1_, String jarg2); + public final static native String DetectorAnalysisResult_nuclide_type__get(long jarg1, DetectorAnalysisResult jarg1_); + public final static native void DetectorAnalysisResult_id_confidence__set(long jarg1, DetectorAnalysisResult jarg1_, String jarg2); + public final static native String DetectorAnalysisResult_id_confidence__get(long jarg1, DetectorAnalysisResult jarg1_); + public final static native void DetectorAnalysisResult_distance__set(long jarg1, DetectorAnalysisResult jarg1_, float jarg2); + public final static native float DetectorAnalysisResult_distance__get(long jarg1, DetectorAnalysisResult jarg1_); + public final static native void DetectorAnalysisResult_dose_rate__set(long jarg1, DetectorAnalysisResult jarg1_, float jarg2); + public final static native float DetectorAnalysisResult_dose_rate__get(long jarg1, DetectorAnalysisResult jarg1_); + public final static native void DetectorAnalysisResult_real_time__set(long jarg1, DetectorAnalysisResult jarg1_, float jarg2); + public final static native float DetectorAnalysisResult_real_time__get(long jarg1, DetectorAnalysisResult jarg1_); + public final static native void DetectorAnalysisResult_detector__set(long jarg1, DetectorAnalysisResult jarg1_, String jarg2); + public final static native String DetectorAnalysisResult_detector__get(long jarg1, DetectorAnalysisResult jarg1_); + public final static native long new_DetectorAnalysisResult(); + public final static native void DetectorAnalysisResult_reset(long jarg1, DetectorAnalysisResult jarg1_); + public final static native boolean DetectorAnalysisResult_isEmpty(long jarg1, DetectorAnalysisResult jarg1_); + public final static native void delete_DetectorAnalysisResult(long jarg1); + public final static native void DetectorAnalysis_remarks__set(long jarg1, DetectorAnalysis jarg1_, long jarg2, StringVector jarg2_); + public final static native long DetectorAnalysis_remarks__get(long jarg1, DetectorAnalysis jarg1_); + public final static native void DetectorAnalysis_algorithm_name__set(long jarg1, DetectorAnalysis jarg1_, String jarg2); + public final static native String DetectorAnalysis_algorithm_name__get(long jarg1, DetectorAnalysis jarg1_); + public final static native void DetectorAnalysis_algorithm_component_versions__set(long jarg1, DetectorAnalysis jarg1_, long jarg2); + public final static native long DetectorAnalysis_algorithm_component_versions__get(long jarg1, DetectorAnalysis jarg1_); + public final static native void DetectorAnalysis_algorithm_creator__set(long jarg1, DetectorAnalysis jarg1_, String jarg2); + public final static native String DetectorAnalysis_algorithm_creator__get(long jarg1, DetectorAnalysis jarg1_); + public final static native void DetectorAnalysis_algorithm_description__set(long jarg1, DetectorAnalysis jarg1_, String jarg2); + public final static native String DetectorAnalysis_algorithm_description__get(long jarg1, DetectorAnalysis jarg1_); + public final static native void DetectorAnalysis_analysis_start_time__set(long jarg1, DetectorAnalysis jarg1_, long jarg2); + public final static native long DetectorAnalysis_analysis_start_time__get(long jarg1, DetectorAnalysis jarg1_); + public final static native void DetectorAnalysis_analysis_computation_duration__set(long jarg1, DetectorAnalysis jarg1_, float jarg2); + public final static native float DetectorAnalysis_analysis_computation_duration__get(long jarg1, DetectorAnalysis jarg1_); + public final static native void DetectorAnalysis_algorithm_result_description__set(long jarg1, DetectorAnalysis jarg1_, String jarg2); + public final static native String DetectorAnalysis_algorithm_result_description__get(long jarg1, DetectorAnalysis jarg1_); + public final static native void DetectorAnalysis_results__set(long jarg1, DetectorAnalysis jarg1_, long jarg2); + public final static native long DetectorAnalysis_results__get(long jarg1, DetectorAnalysis jarg1_); + public final static native long new_DetectorAnalysis(); + public final static native void DetectorAnalysis_reset(long jarg1, DetectorAnalysis jarg1_); + public final static native boolean DetectorAnalysis_is_empty(long jarg1, DetectorAnalysis jarg1_); + public final static native void delete_DetectorAnalysis(long jarg1); + public final static native void MultimediaData_remark__set(long jarg1, MultimediaData jarg1_, String jarg2); + public final static native String MultimediaData_remark__get(long jarg1, MultimediaData jarg1_); + public final static native void MultimediaData_descriptions__set(long jarg1, MultimediaData jarg1_, String jarg2); + public final static native String MultimediaData_descriptions__get(long jarg1, MultimediaData jarg1_); + public final static native void MultimediaData_data__set(long jarg1, MultimediaData jarg1_, long jarg2); + public final static native long MultimediaData_data__get(long jarg1, MultimediaData jarg1_); + public final static native void MultimediaData_data_encoding__set(long jarg1, MultimediaData jarg1_, int jarg2); + public final static native int MultimediaData_data_encoding__get(long jarg1, MultimediaData jarg1_); + public final static native void MultimediaData_capture_start_time__set(long jarg1, MultimediaData jarg1_, long jarg2); + public final static native long MultimediaData_capture_start_time__get(long jarg1, MultimediaData jarg1_); + public final static native void MultimediaData_file_uri__set(long jarg1, MultimediaData jarg1_, String jarg2); + public final static native String MultimediaData_file_uri__get(long jarg1, MultimediaData jarg1_); + public final static native void MultimediaData_mime_type__set(long jarg1, MultimediaData jarg1_, String jarg2); + public final static native String MultimediaData_mime_type__get(long jarg1, MultimediaData jarg1_); + public final static native long new_MultimediaData(); + public final static native void delete_MultimediaData(long jarg1); + public final static native int EnergyCalibration_type(long jarg1, EnergyCalibration jarg1_); + public final static native boolean EnergyCalibration_valid(long jarg1, EnergyCalibration jarg1_); + public final static native long EnergyCalibration_coefficients(long jarg1, EnergyCalibration jarg1_); + public final static native long EnergyCalibration_deviation_pairs(long jarg1, EnergyCalibration jarg1_); + public final static native long EnergyCalibration_channel_energies(long jarg1, EnergyCalibration jarg1_); + public final static native long EnergyCalibration_num_channels(long jarg1, EnergyCalibration jarg1_); + public final static native long new_EnergyCalibration(); + public final static native void EnergyCalibration_set_polynomial(long jarg1, EnergyCalibration jarg1_, long jarg2, long jarg3, FloatVector jarg3_, long jarg4); + public final static native void EnergyCalibration_set_default_polynomial(long jarg1, EnergyCalibration jarg1_, long jarg2, long jarg3, FloatVector jarg3_, long jarg4); + public final static native void EnergyCalibration_set_full_range_fraction(long jarg1, EnergyCalibration jarg1_, long jarg2, long jarg3, FloatVector jarg3_, long jarg4); + public final static native void EnergyCalibration_set_lower_channel_energy__SWIG_0(long jarg1, EnergyCalibration jarg1_, long jarg2, long jarg3, FloatVector jarg3_); + public final static native long EnergyCalibration_memmorysize(long jarg1, EnergyCalibration jarg1_); + public final static native double EnergyCalibration_channel_for_energy(long jarg1, EnergyCalibration jarg1_, double jarg2); + public final static native double EnergyCalibration_energy_for_channel(long jarg1, EnergyCalibration jarg1_, double jarg2); + public final static native float EnergyCalibration_lower_energy(long jarg1, EnergyCalibration jarg1_); + public final static native float EnergyCalibration_upper_energy(long jarg1, EnergyCalibration jarg1_); + public final static native long EnergyCalibration_sm_min_channels_get(); + public final static native long EnergyCalibration_sm_max_channels_get(); + public final static native float EnergyCalibration_sm_polynomial_offset_limit_get(); + public final static native void delete_EnergyCalibration(long jarg1); + public final static native long energy_cal_combine_channels(long jarg1, EnergyCalibration jarg1_, long jarg2); + public final static native long polynomial_binning(long jarg1, FloatVector jarg1_, long jarg2, long jarg3); + public final static native long fullrangefraction_binning__SWIG_0(long jarg1, FloatVector jarg1_, long jarg2, long jarg3, boolean jarg4); + public final static native long fullrangefraction_binning__SWIG_1(long jarg1, FloatVector jarg1_, long jarg2, long jarg3); + public final static native double fullrangefraction_energy(double jarg1, long jarg2, FloatVector jarg2_, long jarg3, long jarg4); + public final static native double polynomial_energy(double jarg1, long jarg2, FloatVector jarg2_, long jarg3); + public final static native double deviation_pair_correction(double jarg1, long jarg2); + public final static native double correction_due_to_dev_pairs(double jarg1, long jarg2); + public final static native long apply_deviation_pair(long jarg1, FloatVector jarg1_, long jarg2); + public final static native long polynomial_coef_to_fullrangefraction(long jarg1, FloatVector jarg1_, long jarg2); + public final static native long fullrangefraction_coef_to_polynomial(long jarg1, FloatVector jarg1_, long jarg2); + public final static native long mid_channel_polynomial_to_fullrangeFraction(long jarg1, FloatVector jarg1_, long jarg2); + public final static native boolean calibration_is_valid(int jarg1, long jarg2, FloatVector jarg2_, long jarg3, long jarg4); + public final static native long polynomial_cal_remove_first_channels(int jarg1, long jarg2, FloatVector jarg2_); + public final static native double find_fullrangefraction_channel__SWIG_0(double jarg1, long jarg2, FloatVector jarg2_, long jarg3, long jarg4, double jarg5); + public final static native double find_fullrangefraction_channel__SWIG_1(double jarg1, long jarg2, FloatVector jarg2_, long jarg3, long jarg4); + public final static native double find_polynomial_channel__SWIG_0(double jarg1, long jarg2, FloatVector jarg2_, long jarg3, long jarg4, double jarg5); + public final static native double find_polynomial_channel__SWIG_1(double jarg1, long jarg2, FloatVector jarg2_, long jarg3, long jarg4); + public final static native void rebin_by_lower_edge(long jarg1, FloatVector jarg1_, long jarg2, FloatVector jarg2_, long jarg3, FloatVector jarg3_, long jarg4, FloatVector jarg4_); + public final static native long energy_cal_from_CALp_file(long jarg1, long jarg2, long jarg3); + public final static native boolean write_CALp_file(long jarg1, long jarg2, String jarg3); + public final static native long D3_MIN_JS_get(); + public final static native long D3_MIN_JS_SIZE_get(); + public final static native long SPECTRUM_CHART_D3_JS_get(); + public final static native long SPECTRUM_CHART_D3_JS_SIZE_get(); + public final static native long SPECTRUM_CHART_D3_CSS_get(); + public final static native long SPECTRUM_CHART_D3_CSS_SIZE_get(); + public final static native long SPECTRUM_CHART_D3_STANDALONE_CSS_get(); + public final static native long SPECTRUM_CHART_D3_STANDALONE_CSS_SIZE_get(); + public final static native boolean write_spectrum_data_js(long jarg1, long jarg2, Measurement jarg2_, long jarg3, D3SpectrumOptions jarg3_, long jarg4, int jarg5); + public final static native boolean write_d3_html(long jarg1, long jarg2, long jarg3, D3SpectrumChartOptions jarg3_); + public final static native boolean write_html_page_header(long jarg1, String jarg2); + public final static native boolean write_js_for_chart(long jarg1, String jarg2, String jarg3, String jarg4, String jarg5); + public final static native boolean write_and_set_data_for_chart(long jarg1, String jarg2, long jarg3); + public final static native boolean write_set_options_for_chart(long jarg1, String jarg2, long jarg3, D3SpectrumChartOptions jarg3_); + public final static native boolean write_html_display_options_for_chart(long jarg1, String jarg2, long jarg3, D3SpectrumChartOptions jarg3_); + public final static native long d3_js(); + public final static native long spectrum_chart_d3_js(); + public final static native long spectrum_char_d3_css(); + public final static native long spectrum_chart_d3_standalone_css(); + public final static native String spectrum_chart_setup_js(); + public final static native long new_D3SpectrumOptions(); + public final static native void D3SpectrumOptions_peaks_json_set(long jarg1, D3SpectrumOptions jarg1_, String jarg2); + public final static native String D3SpectrumOptions_peaks_json_get(long jarg1, D3SpectrumOptions jarg1_); + public final static native void D3SpectrumOptions_line_color_set(long jarg1, D3SpectrumOptions jarg1_, String jarg2); + public final static native String D3SpectrumOptions_line_color_get(long jarg1, D3SpectrumOptions jarg1_); + public final static native void D3SpectrumOptions_peak_color_set(long jarg1, D3SpectrumOptions jarg1_, String jarg2); + public final static native String D3SpectrumOptions_peak_color_get(long jarg1, D3SpectrumOptions jarg1_); + public final static native void D3SpectrumOptions_title_set(long jarg1, D3SpectrumOptions jarg1_, String jarg2); + public final static native String D3SpectrumOptions_title_get(long jarg1, D3SpectrumOptions jarg1_); + public final static native void D3SpectrumOptions_display_scale_factor_set(long jarg1, D3SpectrumOptions jarg1_, double jarg2); + public final static native double D3SpectrumOptions_display_scale_factor_get(long jarg1, D3SpectrumOptions jarg1_); + public final static native void D3SpectrumOptions_spectrum_type_set(long jarg1, D3SpectrumOptions jarg1_, int jarg2); + public final static native int D3SpectrumOptions_spectrum_type_get(long jarg1, D3SpectrumOptions jarg1_); + public final static native void delete_D3SpectrumOptions(long jarg1); + public final static native long new_D3SpectrumChartOptions__SWIG_0(); + public final static native long new_D3SpectrumChartOptions__SWIG_1(String jarg1, String jarg2, String jarg3, String jarg4, boolean jarg5, boolean jarg6, boolean jarg7, boolean jarg8, boolean jarg9, boolean jarg10, boolean jarg11, boolean jarg12, boolean jarg13, boolean jarg14, boolean jarg15, boolean jarg16, boolean jarg17, boolean jarg18, float jarg19, float jarg20, long jarg21); + public final static native void D3SpectrumChartOptions_m_title_set(long jarg1, D3SpectrumChartOptions jarg1_, String jarg2); + public final static native String D3SpectrumChartOptions_m_title_get(long jarg1, D3SpectrumChartOptions jarg1_); + public final static native void D3SpectrumChartOptions_m_xAxisTitle_set(long jarg1, D3SpectrumChartOptions jarg1_, String jarg2); + public final static native String D3SpectrumChartOptions_m_xAxisTitle_get(long jarg1, D3SpectrumChartOptions jarg1_); + public final static native void D3SpectrumChartOptions_m_yAxisTitle_set(long jarg1, D3SpectrumChartOptions jarg1_, String jarg2); + public final static native String D3SpectrumChartOptions_m_yAxisTitle_get(long jarg1, D3SpectrumChartOptions jarg1_); + public final static native void D3SpectrumChartOptions_m_dataTitle_set(long jarg1, D3SpectrumChartOptions jarg1_, String jarg2); + public final static native String D3SpectrumChartOptions_m_dataTitle_get(long jarg1, D3SpectrumChartOptions jarg1_); + public final static native void D3SpectrumChartOptions_m_useLogYAxis_set(long jarg1, D3SpectrumChartOptions jarg1_, boolean jarg2); + public final static native boolean D3SpectrumChartOptions_m_useLogYAxis_get(long jarg1, D3SpectrumChartOptions jarg1_); + public final static native void D3SpectrumChartOptions_m_showVerticalGridLines_set(long jarg1, D3SpectrumChartOptions jarg1_, boolean jarg2); + public final static native boolean D3SpectrumChartOptions_m_showVerticalGridLines_get(long jarg1, D3SpectrumChartOptions jarg1_); + public final static native void D3SpectrumChartOptions_m_showHorizontalGridLines_set(long jarg1, D3SpectrumChartOptions jarg1_, boolean jarg2); + public final static native boolean D3SpectrumChartOptions_m_showHorizontalGridLines_get(long jarg1, D3SpectrumChartOptions jarg1_); + public final static native void D3SpectrumChartOptions_m_legendEnabled_set(long jarg1, D3SpectrumChartOptions jarg1_, boolean jarg2); + public final static native boolean D3SpectrumChartOptions_m_legendEnabled_get(long jarg1, D3SpectrumChartOptions jarg1_); + public final static native void D3SpectrumChartOptions_m_compactXAxis_set(long jarg1, D3SpectrumChartOptions jarg1_, boolean jarg2); + public final static native boolean D3SpectrumChartOptions_m_compactXAxis_get(long jarg1, D3SpectrumChartOptions jarg1_); + public final static native void D3SpectrumChartOptions_m_showPeakUserLabels_set(long jarg1, D3SpectrumChartOptions jarg1_, boolean jarg2); + public final static native boolean D3SpectrumChartOptions_m_showPeakUserLabels_get(long jarg1, D3SpectrumChartOptions jarg1_); + public final static native void D3SpectrumChartOptions_m_showPeakEnergyLabels_set(long jarg1, D3SpectrumChartOptions jarg1_, boolean jarg2); + public final static native boolean D3SpectrumChartOptions_m_showPeakEnergyLabels_get(long jarg1, D3SpectrumChartOptions jarg1_); + public final static native void D3SpectrumChartOptions_m_showPeakNuclideLabels_set(long jarg1, D3SpectrumChartOptions jarg1_, boolean jarg2); + public final static native boolean D3SpectrumChartOptions_m_showPeakNuclideLabels_get(long jarg1, D3SpectrumChartOptions jarg1_); + public final static native void D3SpectrumChartOptions_m_showPeakNuclideEnergyLabels_set(long jarg1, D3SpectrumChartOptions jarg1_, boolean jarg2); + public final static native boolean D3SpectrumChartOptions_m_showPeakNuclideEnergyLabels_get(long jarg1, D3SpectrumChartOptions jarg1_); + public final static native void D3SpectrumChartOptions_m_showEscapePeakMarker_set(long jarg1, D3SpectrumChartOptions jarg1_, boolean jarg2); + public final static native boolean D3SpectrumChartOptions_m_showEscapePeakMarker_get(long jarg1, D3SpectrumChartOptions jarg1_); + public final static native void D3SpectrumChartOptions_m_showComptonPeakMarker_set(long jarg1, D3SpectrumChartOptions jarg1_, boolean jarg2); + public final static native boolean D3SpectrumChartOptions_m_showComptonPeakMarker_get(long jarg1, D3SpectrumChartOptions jarg1_); + public final static native void D3SpectrumChartOptions_m_showComptonEdgeMarker_set(long jarg1, D3SpectrumChartOptions jarg1_, boolean jarg2); + public final static native boolean D3SpectrumChartOptions_m_showComptonEdgeMarker_get(long jarg1, D3SpectrumChartOptions jarg1_); + public final static native void D3SpectrumChartOptions_m_showSumPeakMarker_set(long jarg1, D3SpectrumChartOptions jarg1_, boolean jarg2); + public final static native boolean D3SpectrumChartOptions_m_showSumPeakMarker_get(long jarg1, D3SpectrumChartOptions jarg1_); + public final static native void D3SpectrumChartOptions_m_backgroundSubtract_set(long jarg1, D3SpectrumChartOptions jarg1_, boolean jarg2); + public final static native boolean D3SpectrumChartOptions_m_backgroundSubtract_get(long jarg1, D3SpectrumChartOptions jarg1_); + public final static native void D3SpectrumChartOptions_m_allowDragRoiExtent_set(long jarg1, D3SpectrumChartOptions jarg1_, boolean jarg2); + public final static native boolean D3SpectrumChartOptions_m_allowDragRoiExtent_get(long jarg1, D3SpectrumChartOptions jarg1_); + public final static native void D3SpectrumChartOptions_m_xMin_set(long jarg1, D3SpectrumChartOptions jarg1_, float jarg2); + public final static native float D3SpectrumChartOptions_m_xMin_get(long jarg1, D3SpectrumChartOptions jarg1_); + public final static native void D3SpectrumChartOptions_m_xMax_set(long jarg1, D3SpectrumChartOptions jarg1_, float jarg2); + public final static native float D3SpectrumChartOptions_m_xMax_get(long jarg1, D3SpectrumChartOptions jarg1_); + public final static native void D3SpectrumChartOptions_m_reference_lines_json_set(long jarg1, D3SpectrumChartOptions jarg1_, long jarg2); + public final static native long D3SpectrumChartOptions_m_reference_lines_json_get(long jarg1, D3SpectrumChartOptions jarg1_); + public final static native void delete_D3SpectrumChartOptions(long jarg1); +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SpectrumType.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SpectrumType.java new file mode 100644 index 00000000..dab13e86 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/SpectrumType.java @@ -0,0 +1,54 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public final class SpectrumType { + public final static SpectrumType Foreground = new SpectrumType("Foreground"); + public final static SpectrumType SecondForeground = new SpectrumType("SecondForeground"); + public final static SpectrumType Background = new SpectrumType("Background"); + + public final int swigValue() { + return swigValue; + } + + public String toString() { + return swigName; + } + + public static SpectrumType swigToEnum(int swigValue) { + if (swigValue < swigValues.length && swigValue >= 0 && swigValues[swigValue].swigValue == swigValue) + return swigValues[swigValue]; + for (int i = 0; i < swigValues.length; i++) + if (swigValues[i].swigValue == swigValue) + return swigValues[i]; + throw new IllegalArgumentException("No enum " + SpectrumType.class + " with value " + swigValue); + } + + private SpectrumType(String swigName) { + this.swigName = swigName; + this.swigValue = swigNext++; + } + + private SpectrumType(String swigName, int swigValue) { + this.swigName = swigName; + this.swigValue = swigValue; + swigNext = swigValue+1; + } + + private SpectrumType(String swigName, SpectrumType swigEnum) { + this.swigName = swigName; + this.swigValue = swigEnum.swigValue; + swigNext = this.swigValue+1; + } + + private static SpectrumType[] swigValues = { Foreground, SecondForeground, Background }; + private static int swigNext = 0; + private final int swigValue; + private final String swigName; +} diff --git a/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/StringVector.java b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/StringVector.java new file mode 100644 index 00000000..761fccc9 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/java/gov/sandia/specutils/StringVector.java @@ -0,0 +1,166 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.4.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + +package gov.sandia.specutils; + +public class StringVector extends java.util.AbstractList implements java.util.RandomAccess { + private transient long swigCPtr; + protected transient boolean swigCMemOwn; + + protected StringVector(long cPtr, boolean cMemoryOwn) { + swigCMemOwn = cMemoryOwn; + swigCPtr = cPtr; + } + + protected static long getCPtr(StringVector obj) { + return (obj == null) ? 0 : obj.swigCPtr; + } + + protected static long swigRelease(StringVector obj) { + long ptr = 0; + if (obj != null) { + if (!obj.swigCMemOwn) + throw new RuntimeException("Cannot release ownership as memory is not owned"); + ptr = obj.swigCPtr; + obj.swigCMemOwn = false; + obj.delete(); + } + return ptr; + } + + @SuppressWarnings({"deprecation", "removal"}) + protected void finalize() { + delete(); + } + + public synchronized void delete() { + if (swigCPtr != 0) { + if (swigCMemOwn) { + swigCMemOwn = false; + SpecUtilsSwigJNI.delete_StringVector(swigCPtr); + } + swigCPtr = 0; + } + } + + @SuppressWarnings("this-escape") + public StringVector(String[] initialElements) { + this(); + doReserve(initialElements.length); + + for (String element : initialElements) { + doAdd(element); + } + } + + @SuppressWarnings("this-escape") + public StringVector(Iterable initialElements) { + this(); + for (String element : initialElements) { + doAdd(element); + } + } + + public String get(int index) { + return doGet(index); + } + + public String set(int index, String e) { + return doSet(index, e); + } + + public boolean add(String e) { + modCount++; + doAdd(e); + return true; + } + + public void add(int index, String e) { + modCount++; + doAdd(index, e); + } + + public String remove(int index) { + modCount++; + return doRemove(index); + } + + protected void removeRange(int fromIndex, int toIndex) { + modCount++; + doRemoveRange(fromIndex, toIndex); + } + + public int size() { + return doSize(); + } + + public int capacity() { + return doCapacity(); + } + + public void reserve(int n) { + doReserve(n); + } + + public StringVector() { + this(SpecUtilsSwigJNI.new_StringVector__SWIG_0(), true); + } + + public StringVector(StringVector other) { + this(SpecUtilsSwigJNI.new_StringVector__SWIG_1(StringVector.getCPtr(other), other), true); + } + + public boolean isEmpty() { + return SpecUtilsSwigJNI.StringVector_isEmpty(swigCPtr, this); + } + + public void clear() { + SpecUtilsSwigJNI.StringVector_clear(swigCPtr, this); + } + + public StringVector(int count, String value) { + this(SpecUtilsSwigJNI.new_StringVector__SWIG_2(count, value), true); + } + + private int doCapacity() { + return SpecUtilsSwigJNI.StringVector_doCapacity(swigCPtr, this); + } + + private void doReserve(int n) { + SpecUtilsSwigJNI.StringVector_doReserve(swigCPtr, this, n); + } + + private int doSize() { + return SpecUtilsSwigJNI.StringVector_doSize(swigCPtr, this); + } + + private void doAdd(String x) { + SpecUtilsSwigJNI.StringVector_doAdd__SWIG_0(swigCPtr, this, x); + } + + private void doAdd(int index, String x) { + SpecUtilsSwigJNI.StringVector_doAdd__SWIG_1(swigCPtr, this, index, x); + } + + private String doRemove(int index) { + return SpecUtilsSwigJNI.StringVector_doRemove(swigCPtr, this, index); + } + + private String doGet(int index) { + return SpecUtilsSwigJNI.StringVector_doGet(swigCPtr, this, index); + } + + private String doSet(int index, String val) { + return SpecUtilsSwigJNI.StringVector_doSet(swigCPtr, this, index, val); + } + + private void doRemoveRange(int fromIndex, int toIndex) { + SpecUtilsSwigJNI.StringVector_doRemoveRange(swigCPtr, this, fromIndex, toIndex); + } + +} diff --git a/services/sensorhub-service-oscar/src/main/resources/com/botts/impl/service/oscar/stats/Messages.properties b/services/sensorhub-service-oscar/src/main/resources/com/botts/impl/service/oscar/stats/Messages.properties new file mode 100644 index 00000000..8ff307c6 --- /dev/null +++ b/services/sensorhub-service-oscar/src/main/resources/com/botts/impl/service/oscar/stats/Messages.properties @@ -0,0 +1,3 @@ +stats.starting=Starting stats counting... +stats.finished=Finished stats counting in {0}s +stats.no_previous=No previous stats observation found, calculating from epoch to {0} diff --git a/services/sensorhub-service-oscar/src/main/resources/lib/native/linux/x86_64/libSpecUtils.so b/services/sensorhub-service-oscar/src/main/resources/lib/native/linux/x86_64/libSpecUtils.so new file mode 100644 index 00000000..e88e3fa2 Binary files /dev/null and b/services/sensorhub-service-oscar/src/main/resources/lib/native/linux/x86_64/libSpecUtils.so differ diff --git a/services/sensorhub-service-oscar/src/main/resources/lib/native/linux/x86_64/libSpecUtilsJni.so b/services/sensorhub-service-oscar/src/main/resources/lib/native/linux/x86_64/libSpecUtilsJni.so new file mode 100644 index 00000000..181e1145 Binary files /dev/null and b/services/sensorhub-service-oscar/src/main/resources/lib/native/linux/x86_64/libSpecUtilsJni.so differ diff --git a/services/sensorhub-service-oscar/src/main/resources/lib/native/macosx/aarch64/libSpecUtils.dylib b/services/sensorhub-service-oscar/src/main/resources/lib/native/macosx/aarch64/libSpecUtils.dylib new file mode 100644 index 00000000..54f6577b Binary files /dev/null and b/services/sensorhub-service-oscar/src/main/resources/lib/native/macosx/aarch64/libSpecUtils.dylib differ diff --git a/services/sensorhub-service-oscar/src/main/resources/lib/native/macosx/aarch64/libSpecUtilsJni.dylib b/services/sensorhub-service-oscar/src/main/resources/lib/native/macosx/aarch64/libSpecUtilsJni.dylib new file mode 100644 index 00000000..36280829 Binary files /dev/null and b/services/sensorhub-service-oscar/src/main/resources/lib/native/macosx/aarch64/libSpecUtilsJni.dylib differ