Initialize the dataEditor by passing the search referable as search parameter.

@return a single object if the search has an unique match, a list if multiple matches occurred or
<code>null</code> if nothing was found.
174383
protected Object initializeDataEditor() {
        final String textFieldValue = getKeyComponentText();
        Object ref = super.getValue();
        if ((ref != null) && textFieldValue.equals(getObjectLabel(ref)))
            return getDataEditor().setSelectedSearch(ref);

        return getDataEditor().setSelectedSearch(createFilterFromString(textFieldValue));
    }
764834
@Override
	public synchronized T get() {
		@Nullable T checkedObject = this.object;

		if (checkedObject == null) {
			throw new IllegalStateException("Not initialized");
		}
		return checkedObject;
	}
473236
public ParamValueType<FilterType<T>> getOrCreateInitParam()
   {
      List<Node> nodeList = childNode.get("init-param");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new ParamValueTypeImpl<FilterType<T>>(this, "init-param", childNode, nodeList.get(0));
      }
      return createInitParam();
   }
27745
@Override
	protected String initValuesImpl(final FieldCase ca) {
		if (ca == FieldCase.NULL || ca == FieldCase.BLANK) {
			return null;
		}
		return field.getString(control.getNext(ca));
	}
134598
public @CheckForNull
    TypeQualifierAnnotation getEffectiveTypeQualifierAnnotation() {
        boolean firstPartialResult = true;
        TypeQualifierAnnotation effective = null;

        for (PartialResult partialResult : partialResultList) {
            if (firstPartialResult) {
                effective = partialResult.getTypeQualifierAnnotation();
                firstPartialResult = false;
            } else {
                effective = combine(effective, partialResult.getTypeQualifierAnnotation());
            }
        }

        return effective;
    }
375524
public boolean init() {
	// open model file to load model here ... complete later
	BufferedReader fin = null;
	String modelFile = taggerOpt.modelDir + File.separator + taggerOpt.modelFile;
	
	try {
	    fin = new BufferedReader(new InputStreamReader(new FileInputStream(modelFile), "UTF-8"));
	    
	    // read context predicate map and label map
	    taggerMaps.readCpMaps(fin);
	    
	    System.gc();

	    taggerMaps.readLbMaps(fin);
	    
	    System.gc();
	    
	    // read dictionary 
	    taggerDict.readDict(fin);
	    
	    System.gc();
	    
	    // read features
	    taggerFGen.readFeatures(fin);
	    
	    System.gc();
	    
	    // close model file
	    fin.close();
	    
	} catch (IOException e) {
	    System.out.println("Couldn't open model file: " + modelFile);
	    System.out.println(e.toString());
	    
	    return false;	    
	}
	
	// update feature weights
	if (lambda == null) {
	    int numFeatures = taggerFGen.numFeatures();
	    lambda = new double[numFeatures];
	    for (int i = 0; i < numFeatures; i++) {
		Feature f = (Feature)taggerFGen.features.get(i);
                //System.out.println(f.idx);
		lambda[f.idx] = f.wgt;                
	    }
	}
    
	// call init method of Viterbi object
	if (taggerVtb != null) {
	    taggerVtb.init(this);
	}
	
	return true;
    }
679186
@Override
    public IDocumentStore initialize() {
        if (initialized) {
            return this;
        }

        assertValidConfiguration();

        try {
            if (getConventions().getDocumentIdGenerator() == null) { // don't overwrite what the user is doing
                MultiDatabaseHiLoIdGenerator generator = new MultiDatabaseHiLoIdGenerator(this, getConventions());
                _multiDbHiLo = generator;

                getConventions().setDocumentIdGenerator(generator::generateDocumentId);
            }

            getConventions().freeze();
            initialized = true;
        } catch (Exception e) {
            close();
            throw ExceptionsUtils.unwrapException(e);
        }

        return this;
    }
330343
public void init(Object obj)
    {
        m_bookmark = null;
        m_objectID = null;
        m_dataSource = null;
        m_objectSource = null;
        m_buffer = null;
    }
51279
@SuppressWarnings("unchecked")
    public final V get() {
        InternalThreadLocalMap threadLocalMap = InternalThreadLocalMap.get();
        Object v = threadLocalMap.indexedVariable(index);
        if (v != InternalThreadLocalMap.UNSET) {
            return (V) v;
        }

        return initialize(threadLocalMap);
    }
1016537
@Override
    public TableCellEditor getCellEditor(int row, int column) {
        if (column == 0) {
            return null;
        }

        Item item = getSheetModel().getPropertySheetElement(row);
        if (!item.isProperty()) {
            return null;
        }

        TableCellEditor result = null;
        Property propery = item.getProperty();
        PropertyEditor editor = getEditorFactory().createPropertyEditor(propery);
        if (editor != null) {
            result = new CellEditorAdapter(editor);
        }

        return result;
    }
417229
protected JComponent createViewMenuBar() {
    	if(getPageComponent() instanceof AbstractEditor){
    		AbstractEditor editor = (AbstractEditor)getPageComponent();
    		return editor.getEditorMenuBar();
    	}
    	return null;
    }
300733
public static Editor clear() {
        final Editor editor = getPreferences().edit().clear();
        editor.apply();
        return editor;
    }
1108677
protected IDataSourceType initDataSouceType( final String className )
    {
        final Class<?> c;
        try {
            c = Class.forName( className ); 
        }
        catch ( ClassNotFoundException e ) {
            throw new IllegalArgumentException( "Class not found: " + className,
                                                e );
        }

        final Object o;
        try {
            o = c.newInstance();
        }
        catch ( Exception e ) {
            throw new IllegalArgumentException(
                        "Creating an instance of class '" + className + "' " +
                        "caused a " + e.getClass().getSimpleName() + ": " +
                        e.getMessage(), e );
        }

        if ( ! (o instanceof IDataSourceType) )
            throw new IllegalArgumentException(
                        "Class '" + className + "' is not an implementation " +
                        "of IDataSourceType." );

        return (IDataSourceType) o;
    }
455473
protected void initUserObject() {

        if (m_fieldconfiguration == null) {
            try {
                m_fieldconfiguration = m_searchManager.getFieldConfiguration(getParamFieldconfiguration());
                if (m_fieldconfiguration == null) {
                    m_fieldconfiguration = new CmsLuceneFieldConfiguration();
                }
            } catch (Exception e) {
                m_fieldconfiguration = new CmsLuceneFieldConfiguration();
            }
        }
    }
653625
@PostConstruct
    private void initialize() {
        final MultivaluedMap<String, String> queryParams = uriInfo.getQueryParameters();
        final String offset = multiParam(queryParams, "offset");
        final String page = multiParam(queryParams, "page", "pageNumber");
        final String size = multiParam(queryParams, "size", "pageSize", "limit");
        final String filter = multiParam(queryParams, "filter", "searchText");
        final String sort = multiParam(queryParams, "sort", "sortOrder");
        final OrderDirection orderDirection;
        String orderBy = multiParam(queryParams, "orderBy", "sortName");

        if (StringUtils.isBlank(orderBy) || !RegexSequence.Pattern.ALPHA_NUMERIC.matcher(orderBy).matches()) {
            orderBy = null;
        }

        if ("asc".equalsIgnoreCase(sort)) {
            orderDirection = OrderDirection.ASCENDING;
        } else if ("desc".equalsIgnoreCase(sort)) {
            orderDirection = OrderDirection.DESCENDING;
        } else {
            orderDirection = OrderDirection.UNSPECIFIED;
        }

        final Pagination pagination;
        if (StringUtils.isNotBlank(offset)) {
            pagination = new Pagination(Pagination.Strategy.OFFSET, offset, size);
        } else if (StringUtils.isNotBlank(page) && StringUtils.isNotBlank(size)) {
            pagination = new Pagination(Pagination.Strategy.PAGES, page, size);
        } else {
            pagination = new Pagination(Pagination.Strategy.OFFSET, 0, 100); // Always paginate queries from resources
        }
        this.alpineRequest = new AlpineRequest(getPrincipal(), pagination, filter, orderBy, orderDirection);
    }
974914
@Override
	protected String initValuesImpl(final FieldCase ca) {
		if (ca == FieldCase.NULL || ca == FieldCase.BLANK) {
			return null;
		}
		String s = super.initValuesImpl(ca);
		int counter = 10000;
		while (set.contains(s) && counter > 0) {
			s = super.initValuesImpl(ca);
			counter--;
		}
		if (counter == 0) {
			throw new IllegalStateException("Could not generate unique value");
		}
		set.add(s);
		return s;
	}
160996
@SuppressWarnings("unchecked")
    @Override
    public PropertyEditor find(Class<?> type) {
        if(type == null){
            return null;
        }
        Class<? extends PropertyEditor> editorClass = this.register.get(type);
        if (editorClass != null) {
            try {
                return editorClass.newInstance();
            } catch (Exception e) {
                 //e.printStackTrace();
            }
        }

        final boolean isArray = type.isArray();
        String editorName = BeanUtils.stripPackage(type);
        if (isArray) {
            editorName += EDITOR_ARRAY;
        } else {
            editorName += EDITOR;
        }
        String searchName = null;
        try {
            searchName = BeanUtils.stripClass(type) + "." + editorName;
            editorClass = (Class<? extends PropertyEditor>) BeanUtils.findClass(searchName);
            return editorClass.newInstance();
        } catch (Exception e) {
            //catching, to be compliant with JDK PEM
            if(logger.isLoggable(Level.FINEST)){
                logger.log(Level.FINEST,"Failed to instantiate property editor class  '"+searchName+"'.",e);
            }
        }

        for (String pkg : this.packages) {
            try {
                searchName = pkg + "." + editorName;
                editorClass = (Class<? extends PropertyEditor>) BeanUtils.findClass(searchName);
                return editorClass.newInstance();
            } catch (Exception e) {
                //catching, to be compliant with JDK PEM
                if(logger.isLoggable(Level.FINEST)){
                    logger.log(Level.FINEST,"Failed to instantiate property editor class  '"+searchName+"'.",e);
                }
            }
        }

        if (isArray) {
            Class<?> cellType = type.getComponentType();
            if (find(cellType) != null) {
                return new GenericArrayPropertyEditor(type);
            }
            return null;
        }  else if(type.isPrimitive()){
            return find(BeanUtils.getWrapperTypeFor(type));
        }

        return null;
    }