import org.openhab.core.types.State; //导入依赖的package包/类
/**
 * Converts a value to a openhab state
 * @param value A value to converrt
 * @return A converted state or null
 */
public static State convertToState(Object value) {

	if(value instanceof BigDecimal) {
		return new DecimalType((BigDecimal)value);
		
	} else if(value instanceof Boolean) {
		return (Boolean)value ? OnOffType.ON : OnOffType.OFF;
		
	} else if(value instanceof String) {
		return  new StringType((String)value);
		
	} else if(value == null) {
		return null;
		
	} else {
		logger.error("Unknown data type!");
		return null;
	}
}
 

import org.openhab.core.types.State; //导入依赖的package包/类
/**
 * Creates an openHAB {@link State} in accordance to the class of the given
 * {@code propertyValue}. Currently {@link Date}, {@link BigDecimal} and
 * {@link Boolean} are handled explicitly. All other {@code dataTypes} are
 * mapped to {@link StringType}.
 * <p>
 * If {@code propertyValue} is {@code null}, {@link UnDefType#NULL} will be
 * returned.
 * 
 * @param propertyValue
 * 
 * @return the new {@link State} in accordance to {@code dataType}. Will
 *         never be {@code null}.
 */
private State createState(Object propertyValue) {
	if(propertyValue == null) {
		return UnDefType.NULL;
	}

	Class<?> dataType = propertyValue.getClass();

	if (Date.class.isAssignableFrom(dataType)) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime((Date) propertyValue);
		return new DateTimeType(calendar);
	} else if (BigDecimal.class.isAssignableFrom(dataType)) {
		return new DecimalType((BigDecimal) propertyValue);
	} else if (Boolean.class.isAssignableFrom(dataType)) {
		if((Boolean) propertyValue) {
			return OnOffType.ON;
		} else {
			return OnOffType.OFF;
		}
	} else {
		return new StringType(propertyValue.toString());
	}
}
 

import org.openhab.core.types.State; //导入依赖的package包/类
public static ItemBean createItemBean(Item item, boolean drillDown, Class<? extends State> stateClass, String clientItemName) {
	ItemBean bean;
	if (item instanceof GroupItem && drillDown) {
		GroupItem groupItem = (GroupItem) item;
		GroupItemBean groupBean = new GroupItemBean();
		Collection<ItemBean> members = new HashSet<ItemBean>();
		for (Item member : groupItem.getMembers()) {
			members.add(createItemBean(member, false, null, null));
		}
		groupBean.members = members.toArray(new ItemBean[members.size()]);
		bean = groupBean;
	} else {
		String state = stateClass==null ? item.getState().toString() : item.getStateAs(stateClass).toString();
		String name = clientItemName==null ? item.getName() : clientItemName;
		bean = new ItemBean(name, state);
	}
	return bean;
}
 

import org.openhab.core.types.State; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public State getStateAs(Class<? extends State> typeClass) {
	if(typeClass==UpDownType.class) {
		if(state.equals(PercentType.ZERO)) {
			return UpDownType.UP;
		} else if(state.equals(PercentType.HUNDRED)) {
			return UpDownType.DOWN;
		} else {
			return UnDefType.UNDEF;
		}
	} else if(typeClass==DecimalType.class) {
		if(state instanceof PercentType) {
			return new DecimalType(((PercentType) state).toBigDecimal().divide(new BigDecimal(100), 8, RoundingMode.UP));
		}
	}
	return super.getStateAs(typeClass);
}
 

import org.openhab.core.types.State; //导入依赖的package包/类
/**
 * Publishes the event to all items bound to the same Homematic item.
 */
private void publishToAllBindings(final Event event) {
	new ProviderItemIterator().iterate(event.getBindingConfig(), new ProviderItemIteratorCallback() {

		@Override
		public void next(HomematicBindingConfig providerBindingConfig, Item item, Converter<?> converter) {
			if (!item.getName().equals(event.getItem().getName())) {
				if (event.isCommand()) {
					context.getEventPublisher().postCommand(item.getName(), (Command) event.getType());
				} else {
					State state = converter.convertFromBinding(event.getHmValueItem());
					context.getEventPublisher().postUpdate(item.getName(), state);
				}
			}
		}
	});
}
 

import org.openhab.core.types.State; //导入依赖的package包/类
/**
 * 
 * Main function to parse ASCII string received 
 * @return 
 * 
 */
@Override
protected void parseBuffer(String itemName, Command aCommand, Direction theDirection,ByteBuffer byteBuffer){

	String theUpdate = "";
	try {
		theUpdate = new String(byteBuffer.array(), charset).split("\0")[0];
	} catch (UnsupportedEncodingException e) {
		logger.warn("Exception while attempting an unsupported encoding scheme");
	}

	ProtocolBindingProvider provider = findFirstMatchingBindingProvider(itemName);

	List<Class<? extends State>> stateTypeList = provider.getAcceptedDataTypes(itemName,aCommand);
	
	String transformedResponse = transformResponse(provider.getProtocolCommand(itemName, aCommand),theUpdate);
	State newState = createStateFromString(stateTypeList,transformedResponse);

	if(newState != null) {
		eventPublisher.postUpdate(itemName, newState);							        						
	} else {
		logger.warn("Can not parse input "+theUpdate+" to match command {} on item {}  ",aCommand,itemName);
	}
}
 

import org.openhab.core.types.State; //导入依赖的package包/类
@Override
protected void internalReceiveCommand(String itemName, Command command) {
    for (EnoceanBindingProvider provider : providers) {
        logger.debug("Checking provider with names {}", provider.getItemNames());
        ParameterAddress parameterAddress = provider.getParameterAddress(itemName);
        State actualState = provider.getItem(itemName).getState();
        String parameterKey = parameterAddress.getParameterId();
        CommandConverter<?, ?> commandConverter = converterFactory.getCommandConverter(parameterKey, command);
        if (commandConverter == null) {
            logger.debug("No command converter found for {}. No command will be executed.", parameterAddress);
            return;
        }
        State newState = commandConverter.convertFrom(actualState, command);
        setStateOnDevice(newState, parameterAddress);
    }
}
 

import org.openhab.core.types.State; //导入依赖的package包/类
private void processTitleCommand(String command, String value) {
	if (DISPLAY_PATTERN.matcher(value).matches()) {
		Integer commandNo = Integer.valueOf(value.substring(1, 2));
		String titleValue = value.substring(2);
		
		if (commandNo == 0) {
			displayNowplaying = titleValue.contains("Now Playing");
		}
		
		State state = displayNowplaying ? new StringType(cleanupDisplayInfo(titleValue)) : UnDefType.UNDEF; 
		
		switch (commandNo) {
			case 1:
				sendUpdate(DenonProperty.TRACK.getCode(), state);
			break;
			case 2:
				sendUpdate(DenonProperty.ARTIST.getCode(), state);
			break;
			case 4:
				sendUpdate(DenonProperty.ALBUM.getCode(), state);
			break;
		}
	}
}
 

import org.openhab.core.types.State; //导入依赖的package包/类
@Override
void handleEvent(ZWaveCommandClassValueEvent event, Item item, Map<String, String> arguments) {
	if(arguments.get("scene")==null)
		return;

	int scene = Integer.parseInt(arguments.get("scene"));
	if(scene != (Integer)event.getValue())
		return;
	Integer state = Integer.parseInt(arguments.get("state"));
	ZWaveStateConverter<?,?> converter = this.getStateConverter(item, state);

	if (converter == null) {
		logger.warn("No converter found for item = {}, node = {} endpoint = {}, ignoring event.", item.getName(), event.getNodeId(), event.getEndpoint());
		return;
	}

	State itemState = converter.convertFromValueToState(event.getValue());
	this.getEventPublisher().postUpdate(item.getName(), itemState);
}
 

import org.openhab.core.types.State; //导入依赖的package包/类
/**
 * @{inheritDoc
 */
public State getStateAs(List<Item> items, Class<? extends State> stateClass) {
	State state = calculate(items);
	if(stateClass.isInstance(state)) {
		return state;
	} else {
		if(stateClass == DecimalType.class) {
			if(items!=null) {
				return new DecimalType(items.size() - count(items, activeState));
			} else {
				return DecimalType.ZERO;
			}
		} else {
			return null;
		}
	}
}
 

import org.openhab.core.types.State; //导入依赖的package包/类
/**
 * @{inheritDoc}
 */
@Override
protected void internalReceiveUpdate(String itemName, State newState) {
    // the code being executed when a state was sent on the openHAB
    // event bus goes here. This method is only called if one of the
    // BindingProviders provide a binding for the given 'itemName'.
    if (logger.isDebugEnabled()) {
        logger.debug("internalReceiveUpdate({},{}) is called!", itemName, newState);
    }
}
 

import org.openhab.core.types.State; //导入依赖的package包/类
/**
 * Method post item state into openHAB
 *
 * @param itemName
 * @param state
 */
public void postState(String itemName, State state) {
    if (state == null) {
        logger.warn("{} - Incoming data item {} - Unknown  state", toString(), itemName);
    } else {
        if (logger.isDebugEnabled()) {
            logger.debug("{} - Incoming data - item:{}/state:{}", toString(), itemName, state);
        }

        if (eventPublisher != null) {
            eventPublisher.postUpdate(itemName, state);
        }
    }
}
 

import org.openhab.core.types.State; //导入依赖的package包/类
@Override
public void resourceValueUpdateReceived(EventObject event,
		WSResourceValue value) {

	for (IhcBindingProvider provider : providers) {
		for (String itemName : provider.getItemNames()) {

			int resourceId = provider.getResourceIdForInBinding(itemName);

			if (value.getResourceID() == resourceId) {

				if (!provider.hasInBinding(itemName)) {

					logger.trace(
							"{} has no inbinding...skip update to OpenHAB bus",
							itemName);

				} else {

					Class<? extends Item> itemType = provider
							.getItemType(itemName);
					State state = IhcDataConverter
							.convertResourceValueToState(itemType, value);

					logger.trace(
							"Received resource value update (item='{}', state='{}')",
							new Object[] { itemName, state });

					eventPublisher.postUpdate(itemName, state);

				}
			}

		}
	}
}
 

import org.openhab.core.types.State; //导入依赖的package包/类
/**
 * @{inheritDoc
 */
@Override
protected void internalReceiveUpdate(String itemName, State newState) {
	// the code being executed when a state was sent on the openHAB
	// event bus goes here. This method is only called if one of the
	// BindingProviders provide a binding for the given 'itemName'.
	logger.debug("internalReceiveUpdate() is called!");
}
 

import org.openhab.core.types.State; //导入依赖的package包/类
/**
 * Returns the current heating state
 * @param itemType
 * @return
 */
public State getOnOffState(Class<? extends Item> itemType) {
	if (itemType == StringItem.class)
		return dcbState == 1 ? StringType.valueOf("ON") : StringType
				.valueOf("OFF");
	if (itemType == SwitchItem.class)
		return dcbState == 1 ? OnOffType.ON : OnOffType.OFF;

	// Default to DecimalType
	return DecimalType.valueOf(Integer.toString(dcbState));
}
 

import org.openhab.core.types.State; //导入依赖的package包/类
/**
 * Returns the current frost temperature
 * @param itemType
 * @return
 */
public State getFrostTemperature(Class<? extends Item> itemType) {
	if (itemType == StringItem.class)
		return StringType.valueOf(Double.toString(dcbFrostTemperature));

	// Default to DecimalType
	return DecimalType.valueOf(Double.toString(dcbFrostTemperature));
}
 

import org.openhab.core.types.State; //导入依赖的package包/类
private void postUpdate(Enigma2BindingProvider provider, Item item,
		final String value) {
	Class<? extends Item> itemType = provider.getItemType(item.getName());
	State state = createState(itemType, value);

	if (state != null) {
		if (item instanceof GenericItem) {
			((GenericItem) item).setState(state);
		}
		eventPublisher.postUpdate(item.getName(), state);
	}
}
 

import org.openhab.core.types.State; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
public List<Class<? extends State>> getAcceptedDataTypes(String itemName, Command command) {
	if(itemName != null) {
		IRtransBindingConfig config = (IRtransBindingConfig) bindingConfigs.get(itemName);
		if(config != null) {
			IRtransBindingConfigElement element = config.get(command);
			if(element != null) {
				return element.getAcceptedTypes();
			}
		}
	}
	return null;
}
 

import org.openhab.core.types.State; //导入依赖的package包/类
/**
 * @{inheritDoc
 */
public State calculate(List<Item> items) {
	if(items.size()>0) {
		State state = items.get(0).getState(); 
		for(int i=1; i<items.size(); i++) {
			if(!state.equals(items.get(i).getState())) {
				return UnDefType.UNDEF;
			}
		}
		return state;
	} else {
		return UnDefType.UNDEF;
	}
}
 

import org.openhab.core.types.State; //导入依赖的package包/类
public List<Class<? extends State>> getAcceptedDataTypes() {
	List<Class<? extends State>> list = new ArrayList<Class<? extends State>>();
		/*list.add(OnOffType.class);
		list.add(PercentType.class);
		list.add(UnDefType.class);*/
	return list;
}