public LightDevice() throws InvalidDescriptionException {
super(new File(DESCRIPTION_FILE_NAME));
setSSDPBindAddress(HostInterface.getInetAddress(HostInterface.IPV4_BITMASK, null));
setHTTPBindAddress(HostInterface.getInetAddress(HostInterface.IPV4_BITMASK, null));
Action getPowerAction = getAction("GetPower");
getPowerAction.setActionListener(this);
Action setPowerAction = getAction("SetPower");
setPowerAction.setActionListener(this);
ServiceList serviceList = getServiceList();
Service service = serviceList.getService(0);
service.setQueryListener(this);
powerVar = getStateVariable("Power");
Argument powerArg = getPowerAction.getArgument("Power");
StateVariable powerState = powerArg.getRelatedStateVariable();
AllowedValueList allowList = powerState.getAllowedValueList();
for (int n = 0; n < allowList.size(); n++)
System.out.println("[" + n + "] = " + allowList.getAllowedValue(n));
AllowedValueRange allowRange = powerState.getAllowedValueRange();
System.out.println("maximum = " + allowRange.getMaximum());
System.out.println("minimum = " + allowRange.getMinimum());
System.out.println("step = " + allowRange.getStep());
}
public void inheritFrom(Dynamics src) {
for (DerivedVariable dv : src.derivedVariables) {
derivedVariables.add(dv.makeCopy());
}
for (ConditionalDerivedVariable dv : src.conditionalDerivedVariables) {
conditionalDerivedVariables.add(dv.makeCopy());
}
for (StateVariable sv : src.stateVariables) {
stateVariables.add(sv.makeCopy());
}
for (TimeDerivative td : src.timeDerivatives) {
timeDerivatives.add(td.makeCopy());
}
for (KineticScheme ks : src.kineticSchemes) {
kineticSchemes.add(ks.makeCopy());
}
for (OnStart os : src.onStarts) {
onStarts.add(os.makeCopy());
}
for (OnEvent oe : src.onEvents) {
onEvents.add(oe.makeCopy());
}
for (OnCondition oc : src.onConditions) {
onConditions.add(oc.makeCopy());
}
for (Regime r : src.regimes) {
regimes.add(r.makeCopy());
}
}
public void notifyAllStateVariables() {
ServiceStateTable stateTable = getServiceStateTable();
int tableSize = stateTable.size();
for (int n = 0; n < tableSize; n++) {
StateVariable var = stateTable.getStateVariable(n);
if (var.isSendEvents() == true) notify(var);
}
}
public void setQueryListener(QueryListener queryListener) {
ServiceStateTable stateTable = getServiceStateTable();
int tableSize = stateTable.size();
for (int n = 0; n < tableSize; n++) {
StateVariable var = stateTable.getStateVariable(n);
var.setQueryListener(queryListener);
}
}
public void checkEquations(HashMap<String, Dimensional> cdimHM) throws ContentError {
HashMap<String, Dimensional> dimHM = new HashMap<String, Dimensional>();
dimHM.putAll(cdimHM);
for (RequiredVar rv : p_requiredVars) {
dimHM.put(rv.getName(), rv.getDimensionality());
}
for (StateVariable sv : stateVariables) {
dimHM.put(sv.getName(), sv.getDimensionality());
}
for (FinalParam fp : r_type.getFinalParams()) {
dimHM.put(fp.getName(), fp.getDimensionality());
}
for (InstanceProperty ip : r_type.getInstancePropertys()) {
dimHM.put(ip.getName(), ip.getDimensionality());
}
ExprDimensional tdim = new ExprDimensional();
tdim.setT(1);
dimHM.put("t", tdim);
for (DerivedVariable dv : derivedVariables) {
try {
dimHM.put(dv.getName(), dv.getDimensionality(dimHM));
} catch (ContentError ce) {
E.error("Checking " + dv + " in " + r_type + " " + ce.getMessage());
}
}
for (ConditionalDerivedVariable cdv : conditionalDerivedVariables) {
try {
dimHM.put(cdv.getName(), cdv.getDimensionality(dimHM));
} catch (ContentError ce) {
E.error("Checking " + cdv + " in " + r_type + " " + ce.getMessage());
}
}
for (TimeDerivative td : timeDerivatives) {
td.checkDimensions(dimHM);
}
for (PointResponse pr : onStarts) {
pr.checkEquations(dimHM);
}
for (PointResponse pr : onEvents) {
pr.checkEquations(dimHM);
}
for (OnCondition oc : onConditions) {
oc.checkEquations(dimHM);
oc.checkConditionDimensions(dimHM);
}
}
void updateStateVariableList(TreeNode parentNode, Service service) {
ServiceStateTable stateList = service.getServiceStateTable();
int nStateVariables = stateList.size();
for (int n = 0; n < nStateVariables; n++) {
StateVariable state = stateList.getStateVariable(n);
String stateName = state.getName();
TreeNode stateNode = new TreeNode(stateName);
stateNode.setUserData(state);
parentNode.add(stateNode);
}
}
public StateVariable getStateVariable(String name) {
ServiceStateTable stateTable = getServiceStateTable();
int tableSize = stateTable.size();
for (int n = 0; n < tableSize; n++) {
StateVariable var = stateTable.getStateVariable(n);
String varName = var.getName();
if (varName == null) continue;
if (varName.equals(name) == true) return var;
}
return null;
}
/** * Add the StateVariable to the service.<br> * <br> * Note: This method should be used to create a dynamic<br> * Device withtout writing any XML that describe the device<br> * . <br> * Note: that no control for duplicate StateVariable is done. * * @param var StateVariable that will be added * @author Stefano "Kismet" Lenzi - [email protected] - 2005 */ public void addStateVariable(StateVariable var) { // TODO Some test are done not stable Node stateTableNode = getSCPDNode().getNode(ServiceStateTable.ELEM_NAME); if (stateTableNode == null) { stateTableNode = new Node(ServiceStateTable.ELEM_NAME); /* * Force the node <serviceStateTable> to be the first node inside <scpd> */ // getSCPDNode().insertNode(stateTableNode,0); getSCPDNode().addNode(stateTableNode); } var.setServiceNode(getServiceNode()); stateTableNode.addNode(var.getStateVariableNode()); }
private boolean notify(Subscriber sub, StateVariable stateVar) {
String varName = stateVar.getName();
String value = stateVar.getValue();
String host = sub.getDeliveryHost();
int port = sub.getDeliveryPort();
NotifyRequest notifyReq = new NotifyRequest();
notifyReq.setRequest(sub, varName, value);
HTTPResponse res = notifyReq.post(host, port);
if (res.isSuccessful() == false) return false;
sub.incrementNotifyCount();
return true;
}
public ServiceStateTable getServiceStateTable() {
ServiceStateTable stateTable = new ServiceStateTable();
Node stateTableNode = getSCPDNode().getNode(ServiceStateTable.ELEM_NAME);
if (stateTableNode == null) return stateTable;
Node serviceNode = getServiceNode();
int nNode = stateTableNode.getNNodes();
for (int n = 0; n < nNode; n++) {
Node node = stateTableNode.getNode(n);
if (StateVariable.isStateVariableNode(node) == false) continue;
StateVariable serviceVar = new StateVariable(serviceNode, node);
stateTable.add(serviceVar);
}
return stateTable;
}
public StateType makeStateType(Component cpt, HashMap<String, Double> fixedHM)
throws ContentError, ParseError {
StateType ret = new StateType(cpt.getID(), cpt.getComponentType().getName());
ret.setSimultaneous(simultaneous);
for (ParamValue pv : cpt.getParamValues()) {
String qn = pv.getName();
double qv = pv.getDoubleValue();
ret.addFixed(qn, qv);
fixedHM.put(qn, qv);
}
for (RequiredVar rv : p_requiredVars) {
ret.addIndependentVariable(rv.getName(), rv.getDimensionString());
}
for (ExposedVar ev : p_exposedVars) {
ret.addExposedVariable(ev.getName(), ev.getDimensionString());
}
HashSet<StateVariable> varHS = new HashSet<StateVariable>();
for (StateVariable sv : stateVariables) {
varHS.add(sv);
ret.addStateVariable(sv.getName(), sv.getDimensionString());
if (sv.hasExposure()) {
ret.addExposureMapping(sv.getName(), sv.getExposure().getName());
}
}
for (InstanceProperty ip : cpt.getComponentType().getInstancePropertys()) {
String pnm = ip.getName();
ret.addExposureMapping(pnm, pnm);
ret.addInstanceProperty(ip);
}
/*
for (ExternalQuantity equan : externalQuantitys) {
String qn = equan.getName();
double qv = PathEvaluator.getValue(cpt, equan.getPath());
ret.addFixed(qn, qv);
fixedHM.put(qn, qv); // MUSTDO we don't need both of these:
// either Ext quans shouldn't say they are fixed and we should use ret.addFixed, or it should
// and use fixedHM.put.
}
*/
for (DerivedVariable dv : derivedVariables) {
if (dv.hasExpression()) {
DoubleEvaluator db = dv.getParseTree().makeFloatFixedEvaluator(fixedHM);
ret.addExpressionDerived(dv.getName(), db, dv.getDimensionString());
} else if (dv.hasSelection()) {
ret.addPathDerived(
dv.getName(),
dv.getPath(),
dv.getFunc(),
dv.isRequired(),
dv.getReduce(),
dv.getDimensionString());
} else {
throw new ContentError("Derived variable needs as selection or an expression");
}
if (dv.hasExposure()) {
ret.addExposureMapping(dv.getName(), dv.getExposure().getName());
}
}
for (ConditionalDerivedVariable cdv : conditionalDerivedVariables) {
DoubleEvaluator db = cdv.makeFloatFixedEvaluator(fixedHM);
ret.addExpressionDerived(cdv.getName(), db, cdv.getDimensionString());
if (cdv.hasExposure()) {
ret.addExposureMapping(cdv.getName(), cdv.getExposure().getName());
}
}
for (TimeDerivative sd : timeDerivatives) {
StateVariable sv = sd.getStateVariable();
varHS.remove(sv);
ParseTree pt = sd.getParseTree();
DoubleEvaluator db = pt.makeFloatFixedEvaluator(fixedHM);
ret.addRate(sv.getName(), db, sd.getDimensionString());
}
for (OnStart os : onStarts) {
ActionBlock ea = os.makeEventAction(fixedHM);
ret.addInitialization(ea);
}
for (OnEvent oe : onEvents) {
EventAction er = new EventAction(oe.getPortName());
ActionBlock ea = oe.makeEventAction(fixedHM);
er.setAction(ea);
if (ea == null) {
throw new ContentError("Null action block from OnEvent " + oe);
}
ret.addEventResponse(er);
}
if (regimes.size() > 0) {
for (EventPort p : r_type.getEventPorts()) {
if (p.isDirectionIn()) {
if (onEvents.hasName(p.getName())) {
// OK, the existing action will also send the event on to the active regime
} else {
EventAction er = new EventAction(p.getName());
ret.addEventResponse(er);
}
}
}
}
for (OnCondition oc : onConditions) {
ParseTree pt = oc.getParseTree();
BooleanEvaluator bb = pt.makeBooleanFixedEvaluator(fixedHM);
ConditionAction cr = new ConditionAction(bb);
ActionBlock ea = oc.makeEventAction(fixedHM);
cr.setAction(ea);
ret.addConditionResponse(cr);
}
for (KineticScheme ks : kineticSchemes) {
ArrayList<Component> states = cpt.getChildrenAL(ks.getNodesName());
ArrayList<Component> rates = cpt.getChildrenAL(ks.getEdgesName());
KScheme scheme = ks.makeKScheme(states, rates);
ret.addKScheme(scheme);
}
for (EventPort p : r_type.getEventPorts()) {
if (p.isDirectionIn()) {
ret.addInputPort(p.getName());
}
// TODO - also need output ports done the same way, in case send action is in a sub-regime
}
for (Regime reg : regimes) {
ComponentRegime crb = reg.makeComponentRegime(ret, cpt, copyFixed(fixedHM));
ret.addComponentRegime(crb);
}
// TODO - could do something with children of parent type here, but don't have to as they
// come in again via the structure of the component itself.
/*
for (StateVariable sv : varHS) {
// E.info("sv without derivative " + sv + " in mcb for " + cpt.getID() + " " + cpt.hashCode());
}
*/
ret.fix();
return ret;
}
private void realResolve(Lems lems, Parser parser) throws ContentError, ParseError {
if (lems.looseResolving()) {
// then we expose anything with a name that matches the name of an exposure
HashSet<String> expHS = new HashSet<String>();
for (Exposure exp : getComponentType().getExposures()) {
expHS.add(exp.getName());
}
for (StateVariable sv : stateVariables) {
if (sv.exposure == null && expHS.contains(sv.name)) {
sv.exposure = sv.name;
E.shortWarning(
"Implicitly exposing a state variable because its name matches an exposure: " + sv);
}
}
for (DerivedVariable dv : derivedVariables) {
if (dv.exposure == null && expHS.contains(dv.name)) {
dv.exposure = dv.name;
E.shortWarning(
"Implicitly exposing a derived variable because its name matches an exposure: " + dv);
}
}
for (ConditionalDerivedVariable dv : conditionalDerivedVariables) {
if (dv.exposure == null && expHS.contains(dv.name)) {
dv.exposure = dv.name;
E.shortWarning(
"Implicitly exposing a derived variable because its name matches an exposure: " + dv);
}
}
}
HashMap<String, Integer> exposedHM = new HashMap<String, Integer>();
for (Requirement req : getComponentType().getRequirements()) {
p_requiredVars.add(new RequiredVar(req.getName(), req.getDimension()));
}
for (Exposure exp : getComponentType().getExposures()) {
p_exposedVars.add(new ExposedVar(exp.getName(), exp.getDimension()));
exposedHM.put(exp.getName(), 0);
}
checkMakeValHM();
addToMap(lems.getGlobals(), valHM);
addToMap(lems.getConstantValueds(), valHM);
for (DerivedVariable dvar : derivedVariables) {
dvar.resolve(lems, lems.getDimensions(), r_type, valHM, parser);
if (dvar.hasExposure()) {
countExposure(dvar.getExposure(), exposedHM);
}
}
for (ConditionalDerivedVariable dvar : conditionalDerivedVariables) {
dvar.resolve(lems, lems.getDimensions(), r_type, valHM, parser);
if (dvar.hasExposure()) {
countExposure(dvar.getExposure(), exposedHM);
}
}
for (StateVariable sv : stateVariables) {
sv.resolve(r_type, lems.getDimensions());
if (sv.hasExposure()) {
countExposure(sv.getExposure(), exposedHM);
}
}
for (StateScalarField scf : stateScalarFields) {
scf.resolve(r_type, lems.getDimensions());
}
for (DerivedScalarField dcf : derivedScalarFields) {
dcf.resolve(r_type, lems.getDimensions());
}
for (DerivedPunctateField dpf : derivedPunctateFields) {
dpf.resolve(r_type, lems.getDimensions());
}
for (TimeDerivative sd : timeDerivatives) {
sd.resolve(stateVariables, valHM, parser);
}
for (OnStart os : onStarts) {
os.resolve(this, stateVariables, valHM, parser);
}
for (OnEvent oe : onEvents) {
oe.resolve(this, stateVariables, valHM, parser);
}
for (OnCondition oc : onConditions) {
oc.resolve(this, stateVariables, valHM, parser);
}
for (Regime reg : regimes) {
reg.setBehavior(this);
reg.resolve(stateVariables, lems, parser, exposedHM);
}
for (KineticScheme ks : kineticSchemes) {
ks.resolve(r_type);
}
for (String enm : exposedHM.keySet()) {
if (exposedHM.get(enm) == 0) {
E.oneLineWarning(
"No internal variable is linked to the exposure: "
+ enm
+ " for ComponentType "
+ getComponentType().getName());
}
}
}
public void off() {
onFlag = false;
powerVar.setValue("off");
}
public void on() {
onFlag = true;
powerVar.setValue("on");
}
public boolean queryControlReceived(StateVariable stateVar) {
stateVar.setValue(getPowerState());
return true;
}
