Checks get and set accessors of this field.
@param xml used to check xml configuration
@param aClass class where is the field with the nested mapping
@param nestedField field with nested mapping
@return mapped field
972673
private static MappedField checkAccessors(XML xml, Class<?> aClass, Field nestedField){

		MappedField field = checkGetAccessor(xml, aClass, nestedField);
		verifySetterMethods(aClass,field);
		return field;
	}
145004
public static String mapXMLToObject(String xml) {
		for (int i = 0; i < keyWordMapping.length; i++) {
			if (keyWordMapping[i][0].equalsIgnoreCase(xml)) {
				return keyWordMapping[i][1];
			}
		}
		return xml;
	}
233926
public XML deleteGlobal(Class<?> aClass){
		checksGlobalExistence(aClass);
		
		XmlClass xmlClass = findXmlClass(aClass);
		if(isEmpty(xmlClass.attributes)) deleteClass(aClass);
		else 							 xmlClass.global = null;
		return this;
	}
813046
public void loadAccessors(Class<?> targetClass, MappedField configuredField, MappedField targetField) {
		
		// First checks xml configuration
		xml.fillMappedField(configuredClass, configuredField)
		   .fillMappedField(targetClass, targetField)
		// fill target field with custom methods defined in the configured field
		   .fillOppositeField(configuredClass, configuredField, targetField);

		// If no present custom methods in XML, it checks annotations
		Annotation.fillMappedField(configuredClass,configuredField);
		Annotation.fillMappedField(targetClass,targetField);
		// fill target field with custom methods defined in the configured field
		Annotation.fillOppositeField(configuredClass,configuredField,targetField);
		
	}
614942
private void setMappers(ObjectMapper mapper, XmlMapper xml) {
        synchronized (lock) {
            this.mapper = mapper;
            this.xml = xml;
            // mapper and xml are set to null on invalidation.
            if (mapper != null && xml != null) {
                applyMapperConfiguration(mapper, xml);
            }
        }
    }
518564
public static List<Property> buildFieldProperties(final Class<?> aClass) {
        DescriptionBuilder builder = DescriptionBuilder.builder();
        buildFieldProperties(aClass, builder);
        return builder.buildProperties();
    }
912480
private static void setFields(final Object from, final Object to,
	                              final Field[] fields, final boolean accessible,
	                              final Map objMap, final Map metadataMap)
	{
		for (int f = 0, fieldsLength = fields.length; f < fieldsLength; ++f)
		{
			final Field field = fields[f];
			final int modifiers = field.getModifiers();
			if ((Modifier.STATIC & modifiers) != 0) continue;
			if ((Modifier.FINAL & modifiers) != 0)
				throw new ObjectCopyException("cannot set final field [" + field.getName() + "] of class [" + from.getClass().getName() + "]");
			if (!accessible && ((Modifier.PUBLIC & modifiers) == 0))
			{
				try
				{
					field.setAccessible(true);
				}
				catch (SecurityException e)
				{
					throw new ObjectCopyException("cannot access field [" + field.getName() + "] of class [" + from.getClass().getName() + "]: " + e.toString(), e);
				}
			}
			try
			{
				cloneAndSetFieldValue(field, from, to, objMap, metadataMap);
			}
			catch (Exception e)
			{
				throw new ObjectCopyException("cannot set field [" + field.getName() + "] of class [" + from.getClass().getName() + "]: " + e.toString(), e);
			}
		}
	}
784633
public <T> T access(Class<T> clazz)
    {
        if ( configuration.getClass().equals(clazz) )
        {
            return clazz.cast(configuration);
        }

        try
        {
            return clazz.cast(fieldCache.get(clazz).get(configuration));
        }
        catch ( Exception e )
        {
            log.error("Could not access field for " + clazz, e);
            throw new RuntimeException(e);
        }
    }
1164984
public static void xmlClassExistent(String path, Class<?> aClass){
		throw new XmlMappingClassExistException (MSG.INSTANCE.message(xmlMappingClassExistException1,aClass.getSimpleName(),path));
	}
368180
public static void xmlGlobalExistent(Class<?> aClass) {
		throw new XmlMappingGlobalExistException(MSG.INSTANCE.message(xmlMappingGlobalExistException, aClass.getSimpleName()));
	}
83333
private static Map<String, PropertyAccessor> _getAccessors(
                    final Class<?> clazz
                    )
    {
        Map<String, PropertyAccessor>  accessors = null;

        synchronized (_ACCESSORS_REG_) {
            accessors = _ACCESSORS_REG_.get( clazz );
            if (accessors == null) {
                accessors = PropertyAccessor.findAll( clazz );
                _ACCESSORS_REG_.put( clazz, accessors );
            }
        }

        return accessors;
    }
1162197
public List<StorageAccount> createStorageAccountsFromXml(InputStream xml) {
        try {
            SAXBuilder builder = new SAXBuilder();
            Document doc = builder.build(xml);
            Element root = doc.getRootElement();
            return createStorageAccountsFrom(root);
        } catch (Exception e) {
            String error = "Could not build storage accounts from xml " +
                           "due to: " + e.getMessage();
            throw new DuraCloudRuntimeException(error, e);
        }
    }
854562
private XlsRecordOption getRecordOptionAnnotation(final FieldAccessor accessor) {

        return accessor.getAnnotation(XlsRecordOption.class)
                .orElseGet(() -> new XlsRecordOption() {

                    @Override
                    public Class<? extends Annotation> annotationType() {
                        return XlsRecordOption.class;
                    }

                    @Override
                    public RemainedOperation remainedOperation() {
                        return RemainedOperation.None;
                    }

                    @Override
                    public OverOperation overOperation() {
                        return OverOperation.Break;
                    }
                });


    }
600882
public static void checkLoadingNestedRecordClass(final Class<?> recordClass, final FieldAccessor accessor, 
            final AnnotationReader reader) throws AnnotationInvalidException {
        
        ArgUtils.notNull(recordClass, "recordClass");
        ArgUtils.notNull(accessor, "accessor");
        ArgUtils.notNull(reader, "reader");
        
        // 再帰的にチェックしていく。
        List<Class<?>> nestedRecordClasses = new ArrayList<>();
        checkLoadingNestedRecordClass(recordClass, accessor, reader, nestedRecordClasses);
        
        
    }
1248694
public static final <C> AsmFieldAccess<C> get(AsmClassAccess<C> classAccess, Field f) {
		return new AsmFieldAccess<C>(classAccess, f);
	}
1280139
@SuppressWarnings("unchecked")
  public static <T> T fromXml(Class<T> clazz, String xml) {
    T object = (T) CLASS_2_XSTREAM_INSTANCE.get(clazz).fromXML(xml);
    return object;
  }
84166
public static Map<String, String> getAttributesFromXmlFile(File xmlFile) {
        if (xmlFile == null || !xmlFile.exists())
            return Collections.emptyMap();

        try (Reader reader = createReader(xmlFile)) {
            return getAttributesFromXmlReader(reader);
        }
        catch (IOException | RuntimeException e) {
            return Collections.emptyMap();
        }
    }