エラー情報を追加します。
<p>エラーメッセージのキーは、{@link #getMessageKey()}の値を使用するため、必ず空以外の値を返す必要があります。</p>
<p>エラーメッセージ中の変数は、{@link #getMessageVariables(CellField)}の値を使用します。</p>
@param cellField フィールド情報
16084
public void error(final CellField<T> cellField) {
        ArgUtils.notNull(cellField, "cellField");
        error(cellField, getMessageKey(), getMessageVariables(cellField));
    }
1284809
public String retrieveTargetFieldName(final Field field){
		
		// this list contains the configuredClass with super classes
		List<Class<?>> classes = getAllsuperClasses(configuredClass);
		
		// in case of override only the last global configuration must be analyzed
		Global global = null; 
		// If configuredClass exists in XML configuration file
		for (Class<?> clazz : classes){
		  
		  if(!xml.isMapped(clazz))continue;

		  // only if global configuration is null will be searched global configuration on super classes
		  if(isNull(global)){
			  
			  global = xml.loadGlobals().get(clazz.getName());
			  if( !isNull(global) 
				  && !isPresent(global.getExcluded(), field.getName())
				  && (	isEmpty(global.getAttributes()) 
					 || isPresent(global.getAttributes(), new SimplyAttribute(field.getName()))
					 )
				 ){
				  // get the classes of the xmlField
				  List<Class<?>> globalClasses = toList(global.getClasses());
				  
				  // if mapped field hasn't targetClass in classes parameter
				  if(!globalClasses.isEmpty() && !globalClasses.contains(targetClass)) continue;
				  
				  // get value of xmlField
				  String value = global.getValue();
				  
				  // If the Value is empty, 
				  // then the name of the target field is equal to the configuredField name, 
				  // therefore we pass the default value we use to indicate equality
				  if(isNull(value)) value = DEFAULT_FIELD_VALUE;
				  
				  // loaded all variables, calculates and returns the correspondence
				  return getValue(Collections.<String>emptyList(), globalClasses, value, field.getName(), clazz, targetClass);
			  }
		  }
			  
		  // loads all configured attributes 
		  for(Attribute attribute :xml.loadAttributes().get(clazz.getName())){
				
			// verifies that exists the attribute written in XML in the configured Class
			if(isNull(fieldName(clazz,attribute.getName())))	
				Error.attributeAbsent(clazz, attribute);
				
			// if the field given in input isn't equal to xmlField continue with the cycle
			if(!attribute.getName().equals(field.getName())) continue;
				
			// get the classes of the xmlField
			List<Class<?>> attributeClasses = toList(attribute.getClasses());
				
			// if mapped field hasn't targetClass in classes parameter
			if(!attributeClasses.isEmpty() && !attributeClasses.contains(targetClass)) continue;
								
			// get the attributes names of xmlField
			List<String> attributes = new ArrayList<String>();
			if(attribute.getAttributes() != null)
				for (SimplyAttribute targetAttribute : attribute.getAttributes()) 
					attributes.add(targetAttribute.getName());
				
			// get value of xmlField
			String value = null;
			if(!isNull(attribute.getValue()))
				value = attribute.getValue().getName();
			
			// If the Value and Attributes parameters are empty, 
			// then the name of the target field is equal to the configuredField name, 
			// therefore we pass the default value we use to indicate equality
			if(isNull(value) && attributes.isEmpty()) value = DEFAULT_FIELD_VALUE;
				
			// loaded all variables, calculates and returns the correspondence
			return getValue(attributes, attributeClasses, value, field.getName(), clazz, targetClass);
		  }
	    }
		
		// if class is configured in xml the annotated configuration is not searched
		// if it has a configured superclass it's ignored, the priority is valid only for principal class
		if(xml.isInheritedMapped(configuredClass))return THE_FIELD_IS_NOT_CONFIGURED;
		
		// if the XML configuration doesn't exist, checks the annotation existence
		for (Class<?> clazz : classes){
			
			JGlobalMap jglobalMap = clazz.getAnnotation(JGlobalMap.class);
			
			//if the field configuration is defined in the global map
			if(  !isNull(jglobalMap)){
				if(!isPresent(jglobalMap.excluded(), field.getName())
						&& (    isEmpty(jglobalMap.attributes()) 
								|| isPresent(jglobalMap.attributes(), field.getName())
								)){
					
					// get the list of target classes
					List<Class<?>> globalClasses = toList(jglobalMap.classes());
					
					// if mapped field hasn't targetClass in classes parameter
					if(!globalClasses.isEmpty() && !globalClasses.contains(targetClass)) return THE_FIELD_IS_NOT_CONFIGURED;
					
					// get value of configuredField
					String value = jglobalMap.value();
					
					// loaded all variables, calculates and returns the correspondence
					return getValue(Collections.<String>emptyList(), globalClasses, value, field.getName(), configuredClass, targetClass);			
				}
				// If global mapping is defined on this level, global mapping of super classes is ignored.
				// This is necessary to apply configuration override.
				break;
			}
		}
			
		JMap jmap = field.getAnnotation(JMap.class);
		if(isNull(jmap)) return THE_FIELD_IS_NOT_CONFIGURED;
			
		// get the list of target classes
		List<Class<?>> targetClasses = toList(jmap.classes());
			
		// if mapped field hasn't targetClass in classes parameter
		if(!targetClasses.isEmpty() && !targetClasses.contains(targetClass)) return THE_FIELD_IS_NOT_CONFIGURED;
			
		// get the list of target attributes
		List<String> attributes = toList(jmap.attributes());
		
		// get value of configuredField
		String value = jmap.value();
			
		// loaded all variables, calculates and returns the correspondence
		return getValue(attributes, targetClasses, value, field.getName(), configuredClass, targetClass);
		
	}
801714
public String getString(final String fieldName) {
    try {
      return _jsonObject.getString(fieldName);
    } catch (JSONException ex) {
      throw new RuntimeException("Cannot find field", ex);
    }
  }
873969
private static String createMessage(String fieldName, String value) {
        StringBuffer buf = new StringBuffer().append("Value ");

        if (value == null) {
            buf.append("null");
        } else {
            buf.append('"');
            buf.append(value);
            buf.append('"');
        }

        buf.append(" for ").append(fieldName).append(' ').append("is not supported");
        
        return buf.toString();
    }
35653
public static JMessageListener createScreenMessageListener(FieldList record, BaseScreenModel screen)
    {        // Now add listeners to update screen when data changes
        FieldTable table = record.getTable();
        RemoteSession remoteSession = (RemoteSession)table.getRemoteTableType(org.jbundle.model.Remote.class);

        MessageManager messageManager = ((Application)screen.getBaseApplet().getApplication()).getMessageManager();
        MessageReceiver handler = messageManager.getMessageQueue(MessageConstants.RECORD_QUEUE_NAME, MessageConstants.INTRANET_QUEUE).getMessageReceiver();

        Properties properties = new Properties();
        JMessageListener listenerForSession = (JMessageListener)screen.addMessageHandler(record, properties);

        BaseMessageFilter filterForSession = new ClientSessionMessageFilter(MessageConstants.RECORD_QUEUE_NAME, MessageConstants.INTRANET_QUEUE, screen, remoteSession, properties);
        filterForSession.addMessageListener(listenerForSession);
        synchronized (screen.getBaseApplet().getRemoteTask())
        {   // Wait for remote filter to set up before I start accessing the data
            handler.addMessageFilter(filterForSession);
        }
        
        return listenerForSession;
    }
1109018
@Override
    public void visitField(Field obj) {
        String fieldSig = obj.getSignature();
        if ("Ljavax/swing/JLabel;".equals(fieldSig)) {
            FieldAnnotation fa = FieldAnnotation.fromVisitedField(this);

            fieldLabels.add(XFactory.createXField(fa));
        }
    }
550266
@Nonnull
    public BugInstance addField(FieldVariable field) {
        return addField(field.getClassName(), field.getFieldName(), field.getFieldSig(), field.isStatic());
    }
492302
protected void onLookupAfter(StreamMessage input, K lookupKey, V lookupValue)
    {
        // デフォルトでは取得した結果がnull以外の場合、下流にデータを流す。
        if (lookupValue != null)
        {
            StreamMessage message = new StreamMessage();
            message.addField(FieldName.MESSAGE_KEY, lookupKey);
            message.addField(FieldName.MESSAGE_VALUE, lookupValue);

            emitWithGrouping(message, lookupKey, lookupKey.toString());
        }
    }
933727
@SuppressWarnings({"rawtypes", "unchecked"})
    private void initializeFormFieldWidget(final I_CmsFormField formField) {

        final I_CmsFormWidget widget = formField.getWidget();
        if (widget instanceof HasValueChangeHandlers) {
            ((HasValueChangeHandlers)widget).addValueChangeHandler(new ValueChangeHandler() {

                /**
                 * @see com.google.gwt.event.logical.shared.ValueChangeHandler#onValueChange(ValueChangeEvent event)
                 */
                public void onValueChange(ValueChangeEvent event) {

                    boolean inhibitValidation = false;
                    if (event instanceof CmsExtendedValueChangeEvent) {
                        CmsExtendedValueChangeEvent extEvent = (CmsExtendedValueChangeEvent)event;
                        inhibitValidation = extEvent.isInhibitValidation();
                    }
                    Object eventValue = event.getValue();
                    if ((eventValue instanceof String) || (event.getValue() == null)) {
                        // only makes sense for strings
                        defaultHandleValueChange(formField, (String)(event.getValue()), inhibitValidation);
                    } else if (eventValue instanceof Date) {
                        defaultHandleValueChange(formField, "" + ((Date)eventValue).getTime(), inhibitValidation);
                    } else if (eventValue instanceof Boolean) {
                        defaultHandleValueChange(formField, "" + eventValue, inhibitValidation);
                    }

                }
            });
        }

        if (widget instanceof HasKeyPressHandlers) {
            ((HasKeyPressHandlers)widget).addKeyPressHandler(new KeyPressHandler() {

                /**
                 * @see com.google.gwt.event.dom.client.KeyPressHandler#onKeyPress(com.google.gwt.event.dom.client.KeyPressEvent)
                 */
                public void onKeyPress(KeyPressEvent event) {

                    int keyCode = event.getNativeEvent().getKeyCode();
                    defaultHandleKeyPress(formField, keyCode);
                }
            });
        }
    }
909771
private CellFormatResult getCellValue(final POICell poiCell, final Locale locale) {

        final short formatIndex = poiCell.getFormatIndex();
        final String formatPattern = poiCell.getFormatPattern();

        if(formatterResolver.canResolve(formatIndex)) {
            final CellFormatter cellFormatter = formatterResolver.getFormatter(formatIndex);
            return cellFormatter.format(poiCell, locale);

        } else if(formatterResolver.canResolve(formatPattern)) {
            final CellFormatter cellFormatter = formatterResolver.getFormatter(formatPattern);
            return cellFormatter.format(poiCell, locale);

        } else {
            // キャッシュに存在しない場合
            final CellFormatter cellFormatter = formatterResolver.createFormatter(formatPattern) ;
            if(isCache()) {
                formatterResolver.registerFormatter(formatPattern, cellFormatter);
            }
            return cellFormatter.format(poiCell, locale);

        }
    }
801042
private List<Object[]> _getFieldDebugInfos(final String field)
    {
        Map<String, List<Object[]>> debugInfo = _getDebugInfoMap();
        List<Object[]> fieldDebugInfo = debugInfo.get(field);
        if (fieldDebugInfo == null)
        {
            // no field debug-infos yet, create them and store it in the Map
            fieldDebugInfo = new ArrayList<Object[]>();
            debugInfo.put(field, fieldDebugInfo);
        }
        return fieldDebugInfo;
    }
1349345
public KeyField getKeyField(int iKeyFieldSeq)
    {
        if (iKeyFieldSeq >= m_vKeyFieldList.size())
            return null;
        return (KeyField)m_vKeyFieldList.elementAt(iKeyFieldSeq);
    }
865615
public static List<Global> getVariableList( final List<String> variableCells ){
        final List<Global> variableList = new ArrayList<Global>();
        if ( variableCells == null ) return variableList;

        for( String variableCell: variableCells ){
            final StringTokenizer tokens = new StringTokenizer( variableCell, "," );
            while ( tokens.hasMoreTokens() ) {
                final String token = tokens.nextToken();
                final Global vars = new Global();
                final StringTokenizer paramTokens = new StringTokenizer( token, " " );
                vars.setClassName( paramTokens.nextToken() );
                if ( !paramTokens.hasMoreTokens() ) {
                    throw new DecisionTableParseException( "The format for global variables is incorrect. " + "It should be: [Class name, Class otherName]. But it was: [" + variableCell + "]" );
                }
                vars.setIdentifier( paramTokens.nextToken() );
                variableList.add( vars );
            }
        }
        return variableList;
    }
703225
protected String getMessage(String contextId, String fieldPath, String[] faceDescriptorProperty) {
        String[] keys = getMessageKeys(contextId, fieldPath, faceDescriptorProperty);
        return getMessageSourceAccessor().getMessage(new DefaultMessageSourceResolvable(keys, null, keys[0]));
    }
981489
private void addDelegateFields() {
        visitField(ACC_PRIVATE + ACC_FINAL, CLOSURES_MAP_FIELD, "Ljava/util/Map;", null, null);
        if (generateDelegateField) {
            visitField(ACC_PRIVATE + ACC_FINAL, DELEGATE_OBJECT_FIELD, BytecodeHelper.getTypeDescription(delegateClass), null, null);
        }
    }
1308618
public String getMessage(final MSLocale locale, final String key, final String defaultValue) {
        String message = getMessage(locale, key);
        return message == null ? defaultValue : message;
    }
310187
public static String getMessage(final HttpServletRequest request) {
		StringBuilder sb = (StringBuilder) request.getAttribute(MESSAGE_KEY);
		if (sb == null) {
			return "";
		}
		return sb.toString();
	}