Skip to content
Snippets Groups Projects
Commit 24d93fcf authored by Gwenaelle ABEILLE's avatar Gwenaelle ABEILLE
Browse files

migration to maven multi-module

parent fb3b406b
Branches
Tags
No related merge requests found
Show whitespace changes
Inline Side-by-side
archiving-common-collector/pom.xml 0 → 100644
+ 37
− 0
View file @ 24d93fcf
<?xml version="1.0" encoding="UTF-8"?>
<project
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>fr.soleil.deviceservers</groupId>
<artifactId>historicalarchivingservers</artifactId>
<version>2.5.9-SNAPSHOT</version>
</parent>
<groupId>fr.soleil.deviceservers</groupId>
<artifactId>archiving-common-collector</artifactId>
<developers>
<developer>
<id>girardot</id>
<name>Raphaël GIRARDOT</name>
<email>raphael.girardot@synchrotron-soleil.fr</email>
<organization>Synchrotron Soleil</organization>
<organizationUrl>http://www.synchrotron-soleil.fr</organizationUrl>
<roles>
<role>Java Developer</role>
</roles>
<timezone>1</timezone>
</developer>
</developers>
<dependencies>
<dependency>
<groupId>fr.esrf.atk</groupId>
<artifactId>ATKCore</artifactId>
</dependency>
</dependencies>
</project>
archiving-common-collector/src/main/java/Common/Archiver/Collector/ArchiverCollector.java 0 → 100644
+ 330
− 0
View file @ 24d93fcf
package Common.Archiver.Collector;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Date;
import java.util.Enumeration;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import org.slf4j.Logger;
import fr.esrf.TangoDs.Util;
import fr.esrf.tangoatk.core.AttributePolledList;
import fr.esrf.tangoatk.core.ErrorEvent;
import fr.esrf.tangoatk.core.IAttribute;
import fr.esrf.tangoatk.core.IErrorListener;
import fr.soleil.archiving.common.api.tools.ArchivingEvent;
import fr.soleil.archiving.hdbtdb.api.tools.DBTools;
import fr.soleil.archiving.hdbtdb.api.tools.ScalarEvent;
public abstract class ArchiverCollector implements IErrorListener {
private static final long serialVersionUID = -1493388817049590482L;
/**
* This list is the list used by the refresher of the Collector
*/
protected final AttributePolledList attributeList;
// This Map contains the mode counters by attribute
private final Map<String, ModesCounters> attributeModeCounterMap;
// This Map contains the error messages
private final Map<String, String> errorMessageMap;
// Diary file
protected final Logger logger;
/**
* An ModeHandler is associated to each Collector to handle the archiving
* mode
*/
protected ModeHandler m_modeHandler;
/**
* This field represent the refreshing rate of the Collector
*/
private boolean refreshing;
protected final SimpleDateFormat dateFormat;
public ArchiverCollector(ModeHandler modeHandler, Logger logger) {
dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
attributeList = new AttributePolledList();
attributeModeCounterMap = new ConcurrentHashMap<String, ModesCounters>();
errorMessageMap = new ConcurrentHashMap<String, String>();
m_modeHandler = modeHandler;
this.logger = logger;
}
/* Allows to indicate to the collector that a new attribute must be managed */
protected void addAttribute(String name) {
if (name != null) {
String lower = name.toLowerCase();
ModesCounters counters = attributeModeCounterMap.get(lower);
if (counters == null) {
attributeModeCounterMap.put(lower, new ModesCounters());
} else {
logger.debug("ArchiverCollector.addAttribute : The attribute " + name
+ "already exists in the map ==> Counter Re-init");
counters.init();
}
}
}
/* Allows to indicate to the collector that an attribute has been stopped */
protected void removeAttribute(String name) {
if (name != null) {
name = name.toLowerCase();
attributeModeCounterMap.remove(name);
removeErrorMessage(name);
}
}
/* Allows to retrieve the ModesCounters object of one attribute */
protected ModesCounters getModeCounter(String name) {
ModesCounters result;
if (name == null) {
result = null;
} else {
result = attributeModeCounterMap.get(name.toLowerCase());
}
return result;
}
/* Creates a ScalarEvent object from the ErrorEvent with a null value */
protected ScalarEvent getNullValueScalarEvent(ErrorEvent errorEvent, int data_type, int writable) {
return new ScalarEvent(errorEvent.getSource().toString(), data_type, writable, errorEvent.getTimeStamp(), null,
null);
}
/* Return true if the value must be archived, false otherwise */
protected boolean doArchiveEvent(ModesCounters mc, int dataType, Object readValueObject, Object lastValueObject,
String attCompleteName) {
boolean doArchive = false;
try {
doArchive = m_modeHandler.isDataArchivable(mc, dataType, readValueObject, lastValueObject);
} catch (Exception e) {
e.printStackTrace();
logger.error(this.getClass().getSimpleName() + "/doArchiveEvent/catch " + e + " with the value of "
+ attCompleteName);
}
return doArchive;
}
/**
* Triggers the collecting action of this HdbCollector.
*/
protected synchronized void startCollecting() {
if (!attributeList.isEmpty()) {
if (!attributeList.isRefresherStarted()) {
attributeList.setRefreshInterval(m_modeHandler.getRefreshInterval());
attributeList.setSynchronizedPeriod(true);
attributeList.startRefresher();
refreshing = true;
logger.debug(this.getClass() + " start refresh for " + attributeList.getSize() + " attributes");
} else {
// force a refresh for newly added attributes
attributeList.refresh();
logger.debug("FORCING refresh for " + this.getClass());
}
}
}
/**
* Stops the collecting action of this TdbCollector.
*/
protected synchronized void stopCollecting() {
try {
logger.debug(this.getClass() + " stop refresh on " + attributeList.getSize() + " attributes");
attributeList.stopRefresher();
refreshing = false;
} catch (final Exception e) {
Util.out2.println("ERROR !! " + "\r\n" + "\t Origin : \t " + "TdbCollector.stopCollecting" + "\r\n"
+ "\t Reason : \t " + e.getClass().getName() + "\r\n" + "\t Description : \t " + e.getMessage()
+ "\r\n" + "\t Additional information : \t " + "" + "\r\n");
e.printStackTrace();
}
}
/**
* Returns a boolean to know whether the attribute list is empty or not
*
* @return A boolean to know whether the attribute list is empty or not
*/
public boolean hasEmptyList() {
return attributeList.isEmpty();
}
public synchronized int[] loadAssessment() {
final int[] ret = new int[3];
final Enumeration<?> myAttList = attributeList.elements();
while (myAttList.hasMoreElements()) {
final IAttribute nextAttr = (IAttribute) myAttList.nextElement();
final int X = nextAttr.getMaxXDimension();
final int Y = nextAttr.getMaxYDimension();
int type = 0;
if (X > 1) {
type++;
}
if (Y > 1) {
type++;
}
ret[type]++;
}
return ret;
}
public Collection<String> getAttributeList() {
final Collection<String> attributeListResult = new ArrayList<String>();
final Enumeration<?> myAttList = attributeList.elements();
while (myAttList.hasMoreElements()) {
final IAttribute attr = (IAttribute) myAttList.nextElement();
attributeListResult.add(attr.getName());
}
return attributeListResult;
}
public synchronized boolean isCollected(String attributeName) {
boolean isCollected = false;
final Enumeration<?> myAttList = attributeList.elements();
while (myAttList.hasMoreElements()) {
final IAttribute attr = (IAttribute) myAttList.nextElement();
if (attr.getName().equalsIgnoreCase(attributeName)) {
isCollected = true;
break;
}
}
return isCollected;
}
public boolean isPotentiallyCollected(String attributeName) {
boolean collected;
if (attributeName == null) {
collected = false;
} else {
collected = (attributeModeCounterMap.get(attributeName.toLowerCase()) != null);
}
return collected;
}
public synchronized String assessment() {
final StringBuilder ass = new StringBuilder();
ass.append("Collector Reference : " + toString() + "\r\n");
ass.append("Activity (refreshing) : " + isRefreshing() + "\r\n");
ass.append("Mode : " + "\r\n" + m_modeHandler.getMode().toString() + "\r\n");
ass.append("Attribute list (" + attributeList.getSize() + "): " + "\r\n");
final Enumeration<?> myAttList = attributeList.elements();
int i = 1;
while (myAttList.hasMoreElements()) {
final IAttribute iNumberScalar = (IAttribute) myAttList.nextElement();
ass.append("\t" + i++ + "\t" + iNumberScalar.getName() + "\r\n");
}
return ass.toString();
}
public boolean isRefreshing() {
return refreshing;
}
protected void transmitBooleanArray(ArchivingEvent<boolean[]> event, int dim, boolean[] bval, boolean[] nullElements) {
final boolean[] bvalue = Arrays.copyOf(bval, dim);
event.setValue(bvalue, nullElements);
}
protected void transmitByteArray(ArchivingEvent<boolean[]> event, int dim, byte[] bval, boolean[] nullElements) {
final byte[] bvalue = Arrays.copyOf(bval, dim);
event.setValue(bvalue, nullElements);
}
protected void transmitShortArray(ArchivingEvent<boolean[]> event, int dim, short[] sval, boolean[] nullElements) {
final short[] svalue = Arrays.copyOf(sval, dim);
event.setValue(svalue, nullElements);
}
protected void transmitIntArray(ArchivingEvent<boolean[]> event, int dim, int[] ival, boolean[] nullElements) {
final int[] ivalue = Arrays.copyOf(ival, dim);
event.setValue(ivalue, nullElements);
}
protected void transmitLongArray(ArchivingEvent<boolean[]> event, int dim, long[] lval, boolean[] nullElements) {
final long[] lvalue = Arrays.copyOf(lval, dim);
event.setValue(lvalue, nullElements);
}
protected void transmitFloatArray(ArchivingEvent<boolean[]> event, int dim, float[] fval, boolean[] nullElements) {
final float[] fvalue = Arrays.copyOf(fval, dim);
event.setValue(fvalue, nullElements);
}
protected void transmitDoubleArray(ArchivingEvent<boolean[]> event, int dim, double[] dval, boolean[] nullElements) {
final double[] dvalue = Arrays.copyOf(dval, dim);
event.setValue(dvalue, nullElements);
}
protected void transmitObjectArray(ArchivingEvent<boolean[]> event, int dim, Object[] oval, boolean[] nullElements) {
final Object[] ovalue = Arrays.copyOf(oval, dim);
event.setValue(ovalue, nullElements);
}
@Override
public void errorChange(ErrorEvent errorEvent) {
String attributeName = String.valueOf(errorEvent.getSource());
StringBuilder builder = new StringBuilder(getClass().getSimpleName());
builder.append(".errorChange : Unable to read the attribute named ").append(attributeName);
builder.append("\n\tTime: ").append(dateFormat.format(new Date(errorEvent.getTimeStamp())));
Throwable error = errorEvent.getError();
if (error != null) {
builder.append("\n\tReason: ");
DBTools.appendErrorToStringBuilder(builder, error);
}
String errorMess = builder.toString();
logger.error(errorMess);
registerErrorMessage(attributeName, errorMess);
treatErrorEventAfterLogging(errorEvent);
}
protected abstract void treatErrorEventAfterLogging(ErrorEvent errorEvent);
protected void registerErrorMessage(String name, String message) {
if ((name != null) && (message != null)) {
errorMessageMap.put(name.toLowerCase(), message);
}
}
protected void registerErrorMessage(String name, Throwable error) {
registerErrorMessage(name, DBTools.appendErrorToStringBuilder(new StringBuilder(), error).toString());
}
protected void removeErrorMessage(String name) {
if (name != null) {
errorMessageMap.remove(name.toLowerCase());
}
}
public String getErrorMessage(String attributeName) {
String result;
if (attributeName == null) {
result = null;
} else {
result = errorMessageMap.get(attributeName.toLowerCase());
}
return result;
}
// synchronized because of attribute list
public synchronized void clear() {
attributeList.clear();
attributeModeCounterMap.clear();
errorMessageMap.clear();
}
}
archiving-common-collector/src/main/java/Common/Archiver/Collector/ModeHandler.java 0 → 100644
+ 427
− 0
View file @ 24d93fcf
package Common.Archiver.Collector;
import fr.esrf.Tango.DevState;
import fr.esrf.TangoDs.TangoConst;
import fr.soleil.archiving.hdbtdb.api.tools.mode.Mode;
import fr.soleil.archiving.hdbtdb.api.tools.mode.ModeAbsolu;
import fr.soleil.archiving.hdbtdb.api.tools.mode.ModeRelatif;
import fr.soleil.lib.project.ObjectUtils;
public abstract class ModeHandler {
// This class has been defined as abstract just to keep one object in the
// Hdb part and an other in the Tdb part
// It has been done after the archiver developement, and it allows to reduce
// the impacts in the archivers code
private final Mode mode;
private int factorModePeriodic = 0;
private int factorModeAbsolute = 0;
private int factorModeRelative = 0;
private int factorModeThreshold = 0;
public int factorModeDifference = 0;
// private int factorModeCalcul = 0;
// private final String name = this.getClass().getSimpleName();
private int refresherInterval;
private final boolean hasRounding = true;
public ModeHandler(final Mode archiverMode) {
mode = archiverMode;
// Minimum polling interval definition
setMinRefreshInterval();
// Mode factor calculation
initFactor();
}
public int getRefreshInterval() {
return refresherInterval;
}
public Mode getMode() {
return mode;
}
public boolean isDataArchivable(final ModesCounters attModeCounter, final int dataType, final Object currentEvent,
final Object previousEvent) {
double currentEventD = -1;
double previousEventD = -1;
final boolean isCurrentNull = currentEvent == null;
final boolean isPreviousNull = previousEvent == null;
switch (dataType) {
case TangoConst.Tango_DEV_STRING:
// here, currentEvent and previousEvent are String values
if (!ObjectUtils.sameObject(currentEvent, previousEvent)) {
currentEventD = previousEventD + 1;// so that the difference mode's archiving condition is triggered
}
break;
case TangoConst.Tango_DEV_STATE:
final DevState currentEventState = (DevState) currentEvent;
final DevState previousEventState = (DevState) previousEvent;
currentEventD = isCurrentNull ? -1 : currentEventState.value();
previousEventD = isPreviousNull ? -1 : previousEventState.value();
// System.out.println(
// "TdbModeHandler/isDataArchivable/currentEventD/"+currentEventD+"/previousEventD/"+previousEventD
// );
break;
// case TangoConst.Tango_DEV_UCHAR:
// currentEventD = isCurrentNull ? -1 : ((Byte)
// currentEvent).doubleValue();
// previousEventD = isPreviousNull ? -1 : ((Byte)
// previousEvent).doubleValue();
// break;
case TangoConst.Tango_DEV_LONG:
case TangoConst.Tango_DEV_ULONG:
currentEventD = isCurrentNull ? -1 : ((Integer) currentEvent).doubleValue();
previousEventD = isPreviousNull ? -1 : ((Integer) previousEvent).doubleValue();
break;
case TangoConst.Tango_DEV_LONG64:
case TangoConst.Tango_DEV_ULONG64:
currentEventD = isCurrentNull ? -1 : ((Long) currentEvent).doubleValue();
previousEventD = isPreviousNull ? -1 : ((Long) previousEvent).doubleValue();
break;
case TangoConst.Tango_DEV_BOOLEAN:
currentEventD = isCurrentNull ? -1 : ((Boolean) currentEvent).booleanValue() ? 1 : 0;
previousEventD = isPreviousNull ? -1 : ((Boolean) previousEvent).booleanValue() ? 1 : 0;
break;
case TangoConst.Tango_DEV_UCHAR:
case TangoConst.Tango_DEV_SHORT:
case TangoConst.Tango_DEV_USHORT:
currentEventD = isCurrentNull ? -1 : ((Short) currentEvent).doubleValue();
previousEventD = isPreviousNull ? -1 : ((Short) previousEvent).doubleValue();
break;
case TangoConst.Tango_DEV_FLOAT:
currentEventD = isCurrentNull ? -1 : ((Float) currentEvent).doubleValue();
previousEventD = isPreviousNull ? -1 : ((Float) previousEvent).doubleValue();
break;
case TangoConst.Tango_DEV_DOUBLE:
currentEventD = isCurrentNull ? -1 : ((Double) currentEvent).doubleValue();
previousEventD = isPreviousNull ? -1 : ((Double) previousEvent).doubleValue();
break;
default:
if (currentEvent instanceof Number && previousEvent instanceof Number) {
currentEventD = isCurrentNull ? -1 : ((Double) currentEvent).doubleValue();
previousEventD = isPreviousNull ? -1 : ((Double) previousEvent).doubleValue();
}
if (currentEvent instanceof String && previousEvent instanceof String) {
String newCurrentEventString = currentEvent == null ? "" : (String) currentEvent;
String newPreviousEventString = previousEvent == null ? "" : (String) previousEvent;
if (!newCurrentEventString.equals(newPreviousEventString)) {
currentEventD = previousEventD + 1;// so that the difference
// mode's archiving
// condition is triggered
}
}
break;
}
boolean result = false;
// All the modes must be tested at least to increment the various
// counters
if (isDataArchivableModeP(attModeCounter)) {
result = true;
}
if (isDataArchivableModeA(attModeCounter, isCurrentNull, isPreviousNull, currentEventD, previousEventD)) {
result = true;
}
if (isDataArchivableModeR(attModeCounter, isCurrentNull, isPreviousNull, currentEventD, previousEventD)) {
result = true;
}
if (isDataArchivableModeT(attModeCounter, isCurrentNull, currentEventD)) {
result = true;
}
if (isDataArchivableModeC(attModeCounter, isCurrentNull, isPreviousNull, currentEventD, previousEventD)) {
result = true;
}
if (isDataArchivableModeD(attModeCounter, isCurrentNull, isPreviousNull, currentEventD, previousEventD)) {
result = true;
}
if (isDataArchivableModeE(attModeCounter, isCurrentNull, isPreviousNull, currentEventD, previousEventD)) {
result = true;
}
return result;
}
private boolean isDataArchivableModeP(final ModesCounters attModeCounter) {
if (mode.getModeP() == null) {
return false;
}
if (attModeCounter.getCountModeP() < factorModePeriodic) {
// Util.out4.println(m_myName + ".isDataArchivableModeP");
// Util.out4.println("countModePeriodic = " +
// attModeCounter.getCountModeP() + " < " +
// "m_factorModePeriodic = " + m_factorModePeriodic);
attModeCounter.incremCountModeP();
return false;
} else {
attModeCounter.initCountModeP();
// Util.out4.println(m_myName + ".isDataArchivableModeP");
// Util.out4.println("countModePeriodic = " +
// attModeCounter.getCountModeP() + " > " +
// "m_factorModePeriodic = " + m_factorModePeriodic);
return true;
}
}
private boolean isDataArchivableModeA(final ModesCounters attModeCounter, final boolean isCurrentNull,
final boolean isPreviousNull, final double currentEvent, double previousEvent) {
if (mode.getModeA() == null) {
return false;
}
if (attModeCounter.getCountModeA() < factorModeAbsolute) {
attModeCounter.incremCountModeA();
return false;
} else {
attModeCounter.initCountModeA();
if (isCurrentNull && isPreviousNull) {
return false;
} else if (isCurrentNull || isPreviousNull) {
return true;
}
// System.out.println("=/=/=/=/=/=/=/=/=/=//=/=/=/=/=/=/=/=/=/=/=/=/=/=/=/=/=/ derive lente: "
// + m_mode.getModeA().isSlow_drift());
if (mode.getModeA().isSlow_drift()) {
if (mode.getModeA().getPrev_stored_val() == ModeAbsolu.SLOW_DRIFT_FIRST_VAL) {
mode.getModeA().setPrev_stored_val(previousEvent);
} else {
previousEvent = mode.getModeA().getPrev_stored_val();
}
}
final double lowerLimit = previousEvent - Math.abs(mode.getModeA().getValInf());
final double upperLimit = previousEvent + Math.abs(mode.getModeA().getValSup());
if (currentEvent <= lowerLimit || currentEvent >= upperLimit) {
if (mode.getModeA().isSlow_drift()) {
mode.getModeA().setPrev_stored_val(currentEvent);
}
return true;
} else {
return false;
}
}
}
private boolean isDataArchivableModeR(final ModesCounters attModeCounter, final boolean isCurrentNull,
final boolean isPreviousNull, final double currentEvent, double previousEvent) {
if (mode.getModeR() == null) {
return false;
}
if (attModeCounter.getCountModeR() < factorModeRelative) {
attModeCounter.incremCountModeR();
return false;
} else {
attModeCounter.initCountModeR();
if (isCurrentNull && isPreviousNull) {
return false;
} else if (isCurrentNull || isPreviousNull) {
return true;
}
if (mode.getModeR().isSlow_drift()
&& mode.getModeR().getPrev_stored_val() != ModeRelatif.SLOW_DRIFT_FIRST_VAL) {
previousEvent = mode.getModeR().getPrev_stored_val();
}
double lower_limit = 0;
double upper_limit = 0;
final double percentInf = Math.abs(mode.getModeR().getPercentInf() / 100.0);
final double percentSup = Math.abs(mode.getModeR().getPercentSup() / 100.0);
final double deltaInf = percentInf * Math.abs(previousEvent);
final double deltaSup = percentSup * Math.abs(previousEvent);
lower_limit = previousEvent - deltaInf;
upper_limit = previousEvent + deltaSup;
if (currentEvent < lower_limit || currentEvent > upper_limit) {
if (mode.getModeR().isSlow_drift()) {
mode.getModeR().setPrev_stored_val(currentEvent);
}
// System.out.println("TRUE");
return true;
} else {
// System.out.println("FALSE");
return false;
}
}
}
private boolean isDataArchivableModeT(final ModesCounters attModeCounter, final boolean isCurrentNull,
final double currentEvent) {
if (mode.getModeT() == null) {
return false;
}
if (attModeCounter.getCountModeT() < factorModeThreshold) {
attModeCounter.incremCountModeT();
return false;
} else {
attModeCounter.initCountModeT();
if (isCurrentNull) {
return false;
}
/*
* System.out.println (m_myName + ".isDataArchivableModeT \r\n\t" +
* "\r\n\t" + "current value :" + currentEvent + "\r\n\t" +
* "previous value :" + previousEvent);
*/
if (currentEvent <= mode.getModeT().getThresholdInf() || currentEvent >= mode.getModeT().getThresholdSup()) {
// System.out.println ("TRUE");
return true;
} else {
// System.out.println ("FALSE");
return false;
}
}
}
private boolean isDataArchivableModeD(final ModesCounters attModeCounter, final boolean isCurrentNull,
final boolean isPreviousNull, final double currentEvent, final double previousEvent) {
if (mode.getModeD() == null) {
return false;
}
if (attModeCounter.getCountModeD() < factorModeDifference) {
attModeCounter.incremCountModeD();
return false;
} else {
attModeCounter.initCountModeD();
if (isCurrentNull && isPreviousNull || (Double.isNaN(currentEvent) && Double.isNaN(previousEvent))) {
return false;
} else if (isCurrentNull || isPreviousNull) {
return true;
}
// if (isCurrentNull || isPreviousNull) {
// System.out
// .println("IF isDataArchivableModeD: " + (isCurrentNull !=
// isPreviousNull));
// return isCurrentNull != isPreviousNull;
// }
if (currentEvent != previousEvent) {
// System.out.println("TRUE");
return true;
} else {
// System.out.println("FALSE");
return false;
}
}
}
// todo faire la suite ...
private boolean isDataArchivableModeC(final ModesCounters attModeCounter, final boolean isCurrentNull,
final boolean isPreviousNull, final double currentEvent, final double previousEvent) {
return false;
}
private boolean isDataArchivableModeE(final ModesCounters attModeCounter, final boolean isCurrentNull,
final boolean isPreviousNull, final double currentEvent, final double previousEvent) {
return false;
}
private void initFactor() {
if (hasRounding) {
initFactorWithRounding();
} else {
initFactorWithoutRounding();
}
}
private void initFactorWithRounding() {
factorModePeriodic = (int) Math.round(mode.getModeP().getPeriod() * 1.0 / (refresherInterval * 1.0));
if (mode.getModeA() != null) {
factorModeAbsolute = (int) Math.round(mode.getModeA().getPeriod() * 1.0 / (refresherInterval * 1.0));
}
if (mode.getModeR() != null) {
factorModeRelative = (int) Math.round(mode.getModeR().getPeriod() * 1.0 / (refresherInterval * 1.0));
}
if (mode.getModeT() != null) {
factorModeThreshold = (int) Math.round(mode.getModeT().getPeriod() * 1.0 / (refresherInterval * 1.0));
}
if (mode.getModeD() != null) {
factorModeDifference = (int) Math.round(mode.getModeD().getPeriod() * 1.0 / (refresherInterval * 1.0));
}
// if (mode.getModeC() != null) {
// factorModeCalcul = (int) Math.round(mode.getModeC().getPeriod() * 1.0
// / (refresherInterval * 1.0));
// }
}
// Not really used
private void initFactorWithoutRounding() {
if (mode.getModeP().getPeriod() % refresherInterval == 0) {
factorModePeriodic = mode.getModeP().getPeriod() / refresherInterval;
} else {
// Todo send an exception
}
if (mode.getModeA() != null && mode.getModeA().getPeriod() % refresherInterval == 0) {
factorModeAbsolute = mode.getModeA().getPeriod() / refresherInterval;
} else {
// Todo send an exception
}
if (mode.getModeR() != null && mode.getModeR().getPeriod() % refresherInterval == 0) {
factorModeRelative = mode.getModeR().getPeriod() / refresherInterval;
} else {
// Todo send an exception
}
if (mode.getModeT() != null && mode.getModeT().getPeriod() % refresherInterval == 0) {
factorModeThreshold = mode.getModeT().getPeriod() / refresherInterval;
} else {
// Todo send an exception
}
// if (mode.getModeC() != null && mode.getModeC().getPeriod() %
// refresherInterval == 0) {
// factorModeCalcul = mode.getModeC().getPeriod() / refresherInterval;
// }
// else {
// // Todo send an exception
// }
if (mode.getModeD() != null && mode.getModeD().getPeriod() % refresherInterval == 0) {
factorModeDifference = mode.getModeD().getPeriod() / refresherInterval;
} else {
// Todo send an exception
}
}
private void setMinRefreshInterval() {
// the Periodical Mode is supposed to never be null !!
refresherInterval = mode.getModeP().getPeriod();
if (mode.getModeA() != null && refresherInterval > mode.getModeA().getPeriod()) {
refresherInterval = mode.getModeA().getPeriod();
}
if (mode.getModeR() != null && refresherInterval > mode.getModeR().getPeriod()) {
refresherInterval = mode.getModeR().getPeriod();
}
if (mode.getModeT() != null && refresherInterval > mode.getModeT().getPeriod()) {
refresherInterval = mode.getModeT().getPeriod();
}
/*
* if ( ( m_mode.getModeC() != null ) && ( min >
* m_mode.getModeC().getPeriod() ) ) { m_refresherInterval =
* m_mode.getModeC().getPeriod(); }
*/
if (mode.getModeD() != null && refresherInterval > mode.getModeD().getPeriod()) {
refresherInterval = mode.getModeD().getPeriod();
}
}
}
archiving-common-collector/src/main/java/Common/Archiver/Collector/ModesCounters.java 0 → 100644
+ 129
− 0
View file @ 24d93fcf
package Common.Archiver.Collector;
/**
* This class manages all the useful counters for the ModeHandler decision for
* one attribute
*
* @author PIERREJOSEPH
*/
public final class ModesCounters {
private int countModePeriodic;
private int countModeAbsolute;
private int countModeRelative;
private int countModeThreshold;
private int countModeDifference;
private int countModeCalcul;
private int countModeExtern;
private static final int INIT_COUNTER_VALUE = 1;
/**
* Creates a new instance of AttributeModeHandler
*/
public ModesCounters() {
init();
}
public void init() {
initCountModeP();
initCountModeA();
initCountModeR();
initCountModeT();
initCountModeD();
initCountModeC();
initCountModeE();
}
/** ======================= Init methods ======================== **/
public void initCountModeP() {
countModePeriodic = INIT_COUNTER_VALUE;
}
public void initCountModeA() {
countModeAbsolute = INIT_COUNTER_VALUE;
}
public void initCountModeR() {
countModeRelative = INIT_COUNTER_VALUE;
}
public void initCountModeT() {
countModeThreshold = INIT_COUNTER_VALUE;
}
public void initCountModeD() {
countModeDifference = INIT_COUNTER_VALUE;
}
public void initCountModeC() {
countModeCalcul = INIT_COUNTER_VALUE;
}
public void initCountModeE() {
countModeExtern = INIT_COUNTER_VALUE;
}
/** ======================= Gets methods ======================== **/
public int getCountModeP() {
return countModePeriodic;
}
public int getCountModeA() {
return countModeAbsolute;
}
public int getCountModeR() {
return countModeRelative;
}
public int getCountModeT() {
return countModeThreshold;
}
public int getCountModeD() {
return countModeDifference;
}
public int getCountModeC() {
return countModeCalcul;
}
public int getCountModeE() {
return countModeExtern;
}
/** ======================= Increments methods ======================== **/
public void incremCountModeP() {
countModePeriodic++;
}
public void incremCountModeA() {
countModeAbsolute++;
}
public void incremCountModeR() {
countModeRelative++;
}
public void incremCountModeT() {
countModeThreshold++;
}
public void incremCountModeD() {
countModeDifference++;
}
public void incremCountModeC() {
countModeCalcul++;
}
public void incremCountModeE() {
countModeExtern++;
}
@Override
public String toString() {
return "P=" + countModePeriodic + " A=" + countModeAbsolute + " R=" + countModeRelative + " T="
+ countModeThreshold + " C=" + countModeCalcul + " D=" + countModeDifference + "E=" + countModeExtern;
}
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment

The place to be for your source code