How to use org.ogema.core.model.simple

public static long getValue(SingleValueResource sv) {
  if (sv instanceof TimeResource)
    return ((TimeResource) sv).getValue();
  if (sv instanceof IntegerResource)
    return ((IntegerResource) sv).getValue();
    return 0;
}
 

public void setPersistentAccessCount(final IntegerResource r) {
  if (r != null && r.exists()) {
    this.accessCountPersistent = r;
    this.accessCountVolatile = null;
  }
}
 

public static void increaseIfActive(IntegerResource res) {
  if (res.isActive()) 
    res.setValue(res.getValue()+1);
}
public static void setZeroIfActive(IntegerResource res) {

private void createSmsUser(String name, String sms, String password, String host, int port, boolean createActive) {
  SmsConfiguration newSmsUser = smsConfigs.add();
  
  newSmsUser.userName().<StringResource>create().setValue(name);
  newSmsUser.smsEmail().<StringResource>create().setValue(sms);
  newSmsUser.smsEmailPassword().<StringResource>create().setValue(password);
  newSmsUser.smsEmailServer().<StringResource>create().setValue(host);
  newSmsUser.smsEmailPort().<IntegerResource>create().setValue(port);
  newSmsUser.active().<BooleanResource>create().setValue(createActive);
  newSmsUser.activate(true);
}

public void storeEvent(HmEvent e, SingleValueResource res) {
  logger.debug("storing event data for {}@{} to {}", e.getValueKey(), e.getAddress(), res.getPath());
  if (res instanceof FloatResource) {
    ((FloatResource) res).setValue(e.getValueFloat());
  } else if (res instanceof IntegerResource) {
    ((IntegerResource) res).setValue(e.getValueInt());
  } else if (res instanceof StringResource) {
    ((StringResource) res).setValue(e.getValueString());
  } else if (res instanceof BooleanResource) {
    ((BooleanResource) res).setValue(e.getValueBoolean());
  } else {
    logger.warn("HomeMatic parameter resource is of unsupported type: {}", res.getResourceType());
  }
}

public static long getInterval(final TimeResource itvRes, long defaultItv) {
  long proposed = 0;
  if (itvRes.isActive())
    proposed = itvRes.getValue();
  if (proposed < MIN_SUPERVISION_ITV) {
    proposed = defaultItv;
    itvRes.<TimeResource> create().setValue(defaultItv);
    itvRes.activate(false);
  }
  return proposed;
}

private RecordedData getHistoricalData() {
  if (parentResource instanceof FloatResource) {
    return ((FloatResource) parentResource).getHistoricalData();
  }
  else if (parentResource instanceof BooleanResource) {
    return ((BooleanResource) parentResource).getHistoricalData();
  }
  else if (parentResource instanceof IntegerResource) {
    return ((IntegerResource) parentResource).getHistoricalData();
  }
  else if (parentResource instanceof TimeResource) {
    return ((TimeResource) parentResource).getHistoricalData();
  }
  else
    return null;
}
 

@Override
protected void parseValue(Value value, String channelAddress) {
  switch (channelAddress) {
  case "ATTRIBUTE:0001":
    smokeAlert.setValue(value.getBooleanValue());
    smokeAlert.activate(true);
    break;
  case "ATTRIBUTE:0002":
    batteryStatus.setValue(value.getFloatValue());
    batteryStatus.activate(true);
    break;
  }
}

private static long getForecastHorizon(final ConfigPattern config) {
  if (config.forecastHorizon.isActive()) {
    final long try0 = config.forecastHorizon.getValue();
    if (try0 > 0)
      return try0;
  }
  return 24 * 60 * 60 * 1000; // one day
}

@Override
protected void parseValue(Value value, String channelAddress) {
  switch (channelAddress) {
  case "ATTRIBUTE:0001":
    highWater.setValue(value.getStringValue());
    highWater.activate(true);
    break;
  case "ATTRIBUTE:0002":
    batteryStatus.setValue(value.getFloatValue());
    batteryStatus.activate(true);
    break;
  }
}

public int getCount() {
  return counter.getValue();
}
 

public static void setZeroIfActive(IntegerResource res) {
  if (res.isActive()) 
    res.setValue(0);
}

public static AbsoluteSchedule getHistoricalDataSchedule(SingleValueResource resource) throws IllegalArgumentException {
  AbsoluteSchedule schedule = null;
  if (resource instanceof FloatResource)
    schedule = ((FloatResource) resource).historicalData();
  else if (resource instanceof IntegerResource)
    schedule = ((IntegerResource) resource).historicalData();
  else if (resource instanceof TimeResource)
    schedule = ((TimeResource) resource).historicalData();
  else if (resource instanceof BooleanResource)
    schedule = ((BooleanResource) resource).historicalData();
  else if (resource instanceof StringResource)
    throw new IllegalArgumentException("Logging for StringResources not possible");
  return schedule;
}
 

/** Interrupt data collection, but evaluation is maintained and can be restarted*/
public void interrupt() {
  for(ListenerData ld: valueListeners) {
    if(ld.listener != null) ld.resource.removeValueListener(ld.listener);
  }        
}
 

@Override
public void stop() {
  m_device.reading.removeValueListener(this);
}
 

private void createXmppUser(String name, String xmpp, String password, int port, boolean createActive) {
  XmppConfiguration newXmppUser = xmppConfigs.add();
  
  newXmppUser.userName().<StringResource>create().setValue(name);
  newXmppUser.xmpp().<StringResource>create().setValue(xmpp);
  newXmppUser.password().<StringResource>create().setValue(password);
  newXmppUser.port().<IntegerResource>create().setValue(port);
  newXmppUser.active().<BooleanResource>create().setValue(createActive);
  newXmppUser.activate(true);
}

  /** Get Recorded data from SingleValueResource
   * 
   * @param valueResource
   * @return null if type of resource does not support getHistoricalData
   */
  public static RecordedData getRecordedData(SingleValueResource valueResource) {
    if(valueResource instanceof FloatResource)
      return ((FloatResource)valueResource).getHistoricalData();
    if(valueResource instanceof IntegerResource)
      return ((IntegerResource)valueResource).getHistoricalData();
    if(valueResource instanceof TimeResource)
      return ((TimeResource)valueResource).getHistoricalData();
    if(valueResource instanceof BooleanResource)
      return ((BooleanResource)valueResource).getHistoricalData();
    return null;
  }
}

public void close() {
  target.removeValueListener(this);
}
 

private void createEmailUser(String name, String email, String password, String host, int port, boolean createActive) {
  EmailConfiguration newEmailUser = emailConfigs.add();
  
  newEmailUser.userName().<StringResource>create().setValue(name);
  newEmailUser.email().<StringResource>create().setValue(email);
  newEmailUser.password().<StringResource>create().setValue(password);
  newEmailUser.serverURL().<StringResource>create().setValue(host);
  newEmailUser.port().<IntegerResource>create().setValue(port);
  newEmailUser.active().<BooleanResource>create().setValue(createActive);
  newEmailUser.activate(true);
}

private static RecordedData getHistoricalData(SingleValueResource resource) {
  RecordedData rd = null;
  if (resource instanceof FloatResource)
    rd = ((FloatResource) resource).getHistoricalData();
  else if (resource instanceof IntegerResource)
    rd = ((IntegerResource) resource).getHistoricalData();
  else if (resource instanceof TimeResource)
    rd = ((TimeResource) resource).getHistoricalData();
  else if (resource instanceof BooleanResource)
    rd = ((BooleanResource) resource).getHistoricalData();
  else 
    throw new IllegalArgumentException("Logging not possible for resource of type " + resource.getResourceType().getName());
  return rd;
}