Validates this MappedClass
@param mapper the Mapper to use for validation
165617
@SuppressWarnings("deprecation")
    public void validate(final Mapper mapper) {
        new MappingValidator(mapper.getOptions().getObjectFactory()).validate(mapper, this);
    }
1060288
public void setValidators(Map<String,? extends DOObjectValidator> validators){
		logger.info("Adding {} object validators", validators.size());
        m_validators.putAll(validators);
        if (m_validators.size() > 0) {
        	m_enabled = true;
        }
    }
1159167
public Operation createMappedOperationForDeepFetch(Mapper mapper)
    {
        Operation rootOperation = this.getRootOperation();
        if (rootOperation == null) return null;
        return mapper.createMappedOperationForDeepFetch(rootOperation);
    }
741940
private Mapper initializeMapper() {
    try {
      return MapperFactory.getInstance().getMapper(field);
    } catch (NoSuitableMapperException exp) {
      String message = String.format(
          "No suitable mapper found or error occurred creating a mapper for field %s in class %s",
          field.getName(), field.getDeclaringClass().getName());
      throw new NoSuitableMapperException(message, exp);
    }
  }
1297552
private static synchronized <D,S> IMapper<D,S> createMapper(MapperBuilder mapper) throws Throwable{
	    
		Class<Mapper<D,S>> mapperClass = mapper.exist()?mapper.<D,S>get()
				                                       :mapper.<D,S>generate();
		return mapperClass.newInstance();
	}
480603
public function validate()
    {
        if (!$this->translations) {
            throw new MappingException(sprintf('No translations specified for %s', $this->name));
        }

        if (!$this->targetEntity) {
            throw new MappingException(sprintf('No translations targetEntity specified for %s', $this->name));
        }
    }
1103359
@SuppressWarnings("unchecked")
    public final B addMapper(FieldMapper<ROW, T> mapper) {
        setRowMapperBuilder.addMapper(mapper);
        return (B) this;
    }
399740
public <T> void addMapper(Class<T> clazz, StringMapper<T> mapper) {
		addParser(clazz, mapper);
		mappers.put(clazz, mapper);
	}
899991
private void initializeMapper() {
    if (itemClass == null) {
      itemMapper = CatchAllMapper.getInstance();
    } else {
      try {
        itemMapper = MapperFactory.getInstance().getMapper(itemClass);
      } catch (NoSuitableMapperException exp) {
        itemMapper = CatchAllMapper.getInstance();
      }
    }
  }
1017201
public static Map makeMap(Mapper mapper, Enumeration en) {
        return makeMap(mapper, en, false);
    }
1181077
protected void setMapClass(Class mapClass)
    {
        //
        // If the provided map class is a ControlBean type, then locate associated control
        // interface or extension that defines properties.
        //
        if (ControlBean.class.isAssignableFrom(mapClass))
        {
            Class [] intfs = mapClass.getInterfaces();
            for (int i = 0; i < intfs.length; i++)
            {
                if (intfs[i].isAnnotationPresent(ControlInterface.class) ||
                    intfs[i].isAnnotationPresent(ControlExtension.class))
                {
                    mapClass = intfs[i];
                    break;
                }
            }
        }
        else
        {
            if (!mapClass.isAnnotation() &&
                !mapClass.isAnnotationPresent(ControlInterface.class) &&
                !mapClass.isAnnotationPresent(ControlExtension.class))
                throw new IllegalArgumentException(mapClass+" must be Control or annotation type");
        }

        _mapClass = mapClass;
    }
751097
public static void fillMappedField(Class<?> configuredClass, MappedField mappedField){
		
		JMapAccessor accessor = getClassAccessors(configuredClass, mappedField.getValue().getName(),false);
		
		if(isNull(accessor))
			accessor = getFieldAccessors(configuredClass,mappedField.getValue());
		
		if(isNull(accessor)) return;
			
		if(    mappedField.getMethod().equals(Constants.DEFAULT_ACCESSOR_VALUE)
			&& !accessor.get().equals(Constants.DEFAULT_ACCESSOR_VALUE))
			mappedField.getMethod(accessor.get());
			
		if(     mappedField.setMethod().equals(Constants.DEFAULT_ACCESSOR_VALUE)
			&& !accessor.set().equals(Constants.DEFAULT_ACCESSOR_VALUE))
			mappedField.setMethod(accessor.set());
			
	}
206260
static void validateTypeForSchemaMarshalling(Class<?> type) {
    if (isNonCollectionInterface(type) || isAbstract(type)) {
      throw new IllegalArgumentException("Cannot marshal " + type.getSimpleName()
          + ". Interfaces and abstract class cannot be cannot be marshalled into consistent BigQuery data.");
    }
    if (!isCollection(type) && isGenericType(type)) {
      throw new IllegalArgumentException("Cannot marshal " + type.getSimpleName()
          + ". Parameterized type other than Collection<T> cannot be marshalled into consistent BigQuery data.");
    }
    if (Map.class.isAssignableFrom(type)) {
      throw new IllegalArgumentException(
          "Cannot marshal a map into BigQuery data " + type.getSimpleName());
    }
    if (UNSUPPORTED_TYPES.contains(type)) {
      throw new IllegalArgumentException(
          "Type cannot be marshalled into bigquery schema. " + type.getSimpleName());
    }
  }
1097159
public function validateChildClasses()
    {
        if (count($this->childClasses) > 0 && $this->isLeaf) {
            throw new MappingException(sprintf(
                'Cannot map a document as a leaf and define child classes for "%s"',
                $this->name
            ));
        }
    }
845380
public static Mapper mapMapper(final Map map) {
        return new Mapper() {
            public Object map(final Object a) {
                return map.get(a);
            }
        };
    }
237058
private void validate() {
        if(driverClass == null) {
            throw new IllegalArgumentException("Driver class must be specified");
        }
        if(catalog == null || catalog.isEmpty()) {
            throw new IllegalArgumentException("Schema name must be specified");
        }
        if(table == null || table.isEmpty()) {
            throw new IllegalArgumentException("Table name must be specified");
        }
        if(connectionUrl == null || connectionUrl.isEmpty()) {
            if((host != null && !host.isEmpty()) && (port > 0)) {
                connectionUrl(getJdbcUrl());
            } else {
                throw new IllegalArgumentException("You must specify at least one of connectionUrl or host and port properties");
            }
        }
        if(partitionKey == null && numPartitions > 1) {
            throw new IllegalArgumentException("You must define a valid partition key for using more than one partition.");
        }
    }
1083018
public void setValidateMap(final Map<QName, Map<String, Set<String>>> validateMap) {
        this.validateMap = validateMap;
    }