Create an instance of {@link PersonInfo}
8328
@XmlElementDecl(namespace = "http://org/persons/", name = "PersonInfo")
    public JAXBElement<PersonInfo> createPersonInfo(PersonInfo value) {
        return new JAXBElement<PersonInfo>(_PersonInfo_QNAME, PersonInfo.class, null, value);
    }
867953
public AccountInfo getAccountInfo() throws Exception {

        final JSONObject jsonObject = toJSONObject(client.get(getUri(), null));


        return new AccountInfo(client, jsonObject);
    }
741634
public IPerson getPerson(String username) {
        final IPerson rslt = new PersonImpl();
        rslt.setAttribute(IPerson.USERNAME, username);
        rslt.setID(userIdentityStore.getPortalUserId(username));
        rslt.setAttributes(personAttributeDao.getPerson(username).getAttributes());
        return rslt;
    }
5319
private static @Nullable
    User getOrCreateById(@Nonnull String id, @Nonnull String fullName, boolean create) {
        User u = AllUsers.get(id);
        if (u == null && (create || UserIdMapper.getInstance().isMapped(id))) {
            u = new User(id, fullName);
            AllUsers.put(id, u);
            if (!id.equals(fullName) && !UserIdMapper.getInstance().isMapped(id)) {
                try {
                    u.save();
                } catch (IOException x) {
                    LOGGER.log(Level.WARNING, "Failed to save user configuration for " + id, x);
                }
            }
        }
        return u;
    }
34178
private Map<String, Set<PersonRenderer>> createWholeIndex() {
        logger.info("In getWholeIndex");
        final Map<String, Set<PersonRenderer>> aMap = new TreeMap<>();
        if (!getRenderingContext().isUser()) {
            logger.info("Leaving getWholeIndex not logged in");
            return aMap;
        }
        final Collection<Person> persons = getGedObject().find(Person.class);
        for (final Person person : persons) {
            if (isHidden(person)) {
                continue;
            }
            locatePerson(aMap, person);
        }
        logger.info("Leaving getWholeIndex");
        return aMap;
    }
1269788
@RequestMapping("/head")
    public final String person(
            @RequestParam(value = "db",
                required = false,
                defaultValue = "schoeller") final String dbName,
            final Model model) {
        logger.debug("Entering head");

        final RenderingContext context = createRenderingContext();

        final Head head = fetchHead(dbName);

        final String filename = gedbrowserHome + "/" + dbName + ".ged";
        model.addAttribute("filename", filename);
        model.addAttribute("model", headRenderer(context, head));
        model.addAttribute("appInfo", appInfo);

        return "head";
    }
547684
@SuppressWarnings({ "rawtypes", "unchecked", "deprecation" })
    protected TypeInformation<?> createInfo(Type fieldType) {

        if (fieldType.equals(this.type)) {
            return this;
        }

        if (fieldType instanceof Class) {
            return new ClassTypeInformation((Class<?>) fieldType);
        }

        Class<S> resolveType = resolveClass(fieldType);
        Map<TypeVariable, Type> variableMap = new HashMap<TypeVariable, Type>();
        variableMap.putAll(GenericTypeResolver.getTypeVariableMap(resolveType));

        if (fieldType instanceof ParameterizedType) {

            ParameterizedType parameterizedType = (ParameterizedType) fieldType;

            TypeVariable<Class<S>>[] typeParameters = resolveType.getTypeParameters();
            Type[] arguments = parameterizedType.getActualTypeArguments();

            for (int i = 0; i < typeParameters.length; i++) {
                variableMap.put(typeParameters[i], arguments[i]);
            }

            return new ParametrizedTypeInformation(parameterizedType, this, variableMap);
        }

        if (fieldType instanceof TypeVariable) {
            TypeVariable<?> variable = (TypeVariable<?>) fieldType;
            return new TypeVariableTypeInformation(variable, type, this, variableMap);
        }

        if (fieldType instanceof GenericArrayType) {
            return new GenericArrayTypeInformation((GenericArrayType) fieldType, this, variableMap);
        }

        if (fieldType instanceof WildcardType) {

            WildcardType wildcardType = (WildcardType) fieldType;
            return new WildcardTypeInformation(wildcardType, variableMap);
        }

        throw new IllegalArgumentException();
    }
21387
public static TypeInformation<?> createTypeInfo(Type t) {
		ArrayList<Type> typeHierarchy = new ArrayList<Type>();
		typeHierarchy.add(t);
		return createTypeInfoWithTypeHierarchy(typeHierarchy, t, null, null);
	}
1236375
private static FieldInfo getFieldInfo(String name)
    {
        FieldInfo info = (FieldInfo)__info.get(name);
        if (info==null)
            info = new FieldInfo(name,false);
        return info;
    }
1359788
public InformationMessage createINF() {
        InformationMessage msg = new InformationMessageImpl(_INF_HOLDER.mandatoryCodes, _INF_HOLDER.mandatoryVariableCodes,
                _INF_HOLDER.optionalCodes, _INF_HOLDER.mandatoryCodeToIndex, _INF_HOLDER.mandatoryVariableCodeToIndex,
                _INF_HOLDER.optionalCodeToIndex);
        return msg;
    }
373967
private StatementResult addPerson( final Transaction tx, final String name )
    {
        return tx.run( "CREATE (:Person {name: $name})", parameters( "name", name ) );
    }
370436
@RequestMapping(
            value = USERINFO_ENDPOINT_URI,
            produces = USERINFO_CONTENT_TYPE,
            method = {RequestMethod.GET, RequestMethod.POST})
    public String userInfo(
            HttpServletRequest request,
            @RequestParam(value = "claims", required = false) String claims,
            @RequestParam(value = "groups", required = false) String groups) {

        final IPerson person = personManager.getPerson(request);
        return createToken(person, claims, groups);
    }
684676
@JsonIgnore
    public void setUserInfoCache(final Map<Serializable, Set<IPersonAttributes>> userInfoCache) {
        if (userInfoCache == null) {
            throw new IllegalArgumentException("userInfoCache may not be null");
        }

        this.userInfoCache = userInfoCache;
    }
1160250
public void setupUserInfo()
    {
        MessageProcessInfo recMessageProcessInfo = null;
        try {
            Record recUser = this.getMainRecord();
            Object bookmark = recUser.getLastModified(DBConstants.BOOKMARK_HANDLE);
            recUser = recUser.setHandle(bookmark, DBConstants.BOOKMARK_HANDLE);
            if ((recUser == null) ||
                (recUser.getEditMode() == DBConstants.EDIT_NONE) || (recUser.getEditMode() == DBConstants.EDIT_ADD))
                    return;     // Never
        
            Map<String, Object> properties = this.getSiteProperties();
            RunRemoteProcessMessageData createSiteRequest = this.setupUserProperties(properties);
        
            recMessageProcessInfo = new MessageProcessInfo(this);
            recMessageProcessInfo.setKeyArea(MessageProcessInfo.CODE_KEY);
            recMessageProcessInfo.getField(MessageProcessInfo.CODE).setString("RunRemoteProcessRQ");
            if (recMessageProcessInfo.seek(null))
            {
                TrxMessageHeader trxMessageHeader = recMessageProcessInfo.createProcessMessageHeader(null, MessageTransport.XML);
                if (trxMessageHeader == null)
                    return;
                trxMessageHeader.put(TrxMessageHeader.DESTINATION_PARAM, properties.get(TrxMessageHeader.DESTINATION_PARAM));
                trxMessageHeader.put(MessageTransport.MANUAL_RESPONSE_PARAM, DBConstants.TRUE);    // For testing, allow manual requests
                if (m_intRegistryID != null)
                    trxMessageHeader.put(TrxMessageHeader.REGISTRY_ID, m_intRegistryID);    // The return Queue ID
                BaseMessage message = createSiteRequest.getMessage();
                message.setMessageHeader(trxMessageHeader);
                if (!MessageTransport.DIRECT.equalsIgnoreCase((String)trxMessageHeader.get(MessageTransport.SEND_MESSAGE_BY_PARAM)))
                {
                    MessageManager messageManager = ((Application)this.getTask().getApplication()).getMessageManager();
                    if (messageManager != null)
                        messageManager.sendMessage(message);
                }
            }
        } catch (DBException ex) {
            ex.printStackTrace();
        } finally {
            recMessageProcessInfo.free();
        }
            
        synchronized (this)
        {
           try {
               waiting = true;
               this.wait(40000);
           } catch (InterruptedException ex) {
               ex.printStackTrace();
           }
           if (waiting)
               strMessage = "Error: Timeout on message call";
        }
    }
965786
@Override
    public final Set<IPersonAttributes> getPeopleWithMultivaluedAttributes(final Map<String, List<Object>> query,
                                                                           final IPersonAttributeDaoFilter filter) {
        Validate.notNull(query, "query may not be null.");

        //Generate the query to pass to the subclass
        final QB queryBuilder = this.generateQuery(query);
        if (queryBuilder == null && (this.queryAttributeMapping != null || this.useAllQueryAttributes == true)) {
            this.logger.debug("No queryBuilder was generated for query " + query + ", null will be returned");

            return null;
        }

        //Get the username from the query, if specified
        final IUsernameAttributeProvider usernameAttributeProvider = this.getUsernameAttributeProvider();
        final String username = usernameAttributeProvider.getUsernameFromQuery(query);

        //Execute the query in the subclass
        final List<IPersonAttributes> unmappedPeople = this.getPeopleForQuery(queryBuilder, username);
        if (unmappedPeople == null) {
            return null;
        }

        //Map the attributes of the found people according to resultAttributeMapping if it is set
        final Set<IPersonAttributes> mappedPeople = new LinkedHashSet<>();
        for (final IPersonAttributes unmappedPerson : unmappedPeople) {
            final IPersonAttributes mappedPerson = this.mapPersonAttributes(unmappedPerson);
            mappedPeople.add(mappedPerson);
        }

        return Collections.unmodifiableSet(mappedPeople);
    }
219727
private NamedAdminObjectServiceInfo createNamedAdminObjectServiceInfo(String id) {
        NamedAdminObjectServiceInfo aosInfo = adminObjectServices.get(id);
        if (aosInfo == null) {
            aosInfo = new NamedAdminObjectServiceInfo(id,
                            new ConcurrentServiceReferenceSet<AdminObjectService>(REFERENCE_ADMIN_OBJECT_SERVICES),
                            new ConcurrentServiceReferenceSet<AdminObjectService>(REFERENCE_ADMIN_OBJECT_SERVICES));
            adminObjectServices.put(id, aosInfo);
        }
        return aosInfo;
    }
492418
def create(self, name):
        """"""
        with contextlib.closing(self.database.cursor()) as cursor:
            cursor.execute('INSERT INTO users(name) VALUES (?)', (name,))
            return cursor.lastrowid