Return a url for L{OrganizerFragment} which will display C{person} in
        state C{viewState}.

        @type person: L{Person}
        @type viewState: L{ORGANIZER_VIEW_STATES} constant.

        @rtype: L{url.URL}
544947
def urlForViewState(self, person, viewState):
        
        # ideally there would be a more general mechanism for encoding state
        # like this in a url, rather than ad-hoc query arguments for each
        # fragment which needs to do it.
        organizerURL = self._webTranslator.linkTo(self.storeID)
        return url.URL(
            netloc='', scheme='',
            pathsegs=organizerURL.split('/')[1:],
            querysegs=(('initial-person', person.name),
                       ('initial-state', viewState)))
179558
protected UrlState determineUrlState(
            final IPortletWindow portletWindow,
            final IPortletUrlBuilder targetedPortletUrlBuilder) {
        final WindowState requestedWindowState;
        if (targetedPortletUrlBuilder == null) {
            requestedWindowState = null;
        } else {
            requestedWindowState = targetedPortletUrlBuilder.getWindowState();
        }

        return determineUrlState(portletWindow, requestedWindowState);
    }
193468
def show
      user = ::User.from_url_component(params[:id])
      return redirect_to root_path, alert: "User '#{params[:id]}' does not exist" if user.nil?
      @presenter = Hyrax::UserProfilePresenter.new(user, current_ability)
    end
257709
def getImportPeople(self):
        
        fragment = ImportPeopleWidget(self.organizer)
        fragment.setFragmentParent(self)
        return fragment
24486
def get_absolute_url(self):
        
        # Get the appropriate draft or published parent object for the current
        # item, otherwise we risk mixing the draft parent URL with a published
        # item's URL etc.
        if self.is_draft:
            visible_parent = self.parent.get_draft()
        else:
            # Fallback to draft URL for unpublished parent.
            visible_parent = self.parent.get_published() or \
                self.parent.get_draft()

        # Appending "/" to avoid a) django redirect and b) incorrect edit slug
        # for the admin.
        return urljoin(visible_parent.get_absolute_url(), self.slug + "/")
907100
def peopleTable(self, request, tag):
        
        f = PersonScrollingFragment(
            self.organizer, None, Person.name, self.wt)
        f.setFragmentParent(self)
        f.docFactory = webtheme.getLoader(f.fragmentName)
        return f
663530
protected PresentationState getPresentationState(HttpServletRequest request) {
    String attrName = getPresentationAttrName();

    if ((attrName == null) ||
         (attrName.equals("NONE"))) {
      return null;
    }

    /* First try the request */

    Object o = request.getAttribute(attrName);

    if (o == null) {
      HttpSession sess = request.getSession(false);

      if (sess == null) {
        return null;
      }

      o = sess.getAttribute(attrName);
    }

    if (o == null) {
      return null;
    }

    PresentationState ps = (PresentationState)o;

    if (debug()) {
      ps.debugDump("ConfiguredXSLTFilter");
    }

    return ps;
  }
165219
public BinderConfiguration getViewStateBinderConfiguration(final ViewState state) {
        val field = ReflectionUtils.findField(state.getViewFactory().getClass(), "binderConfiguration");
        ReflectionUtils.makeAccessible(field);
        return (BinderConfiguration) ReflectionUtils.getField(field, state.getViewFactory());
    }
1074215
public String getState()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.entry(tc, "getState");
    String state = 
      messageProcessor.getDestinationManager().getDestinationIndex().getState(foreignDest).toString();
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.entry(tc, "getState");
    return state;
  }
582446
async function parseUrlsOption (state, urls) {
  if (!urls || urls.length === 0) {
    // get URLs for all sections across all pages
    const pages = await getDocPages(state)
    return (await pages.reduce(toSectionUrls.bind(null, state), [])).map(normalizeUrl)
  }

  const normalizedUrls = urls.map(normalizeUrl)
  const invalidUrls = normalizedUrls.filter(isntV3DocumentationUrl)
  if (invalidUrls.length) {
    throw new Error(`Invalid URLs: ${invalidUrls.join(', ')}`)
  }

  const pageUrls = normalizedUrls.filter(isPageUrl)

  const sectionUrls = normalizedUrls.filter(isSectionUrl)
  return _.uniq((await pageUrls.reduce(toSectionUrls.bind(null, state), [])).concat(sectionUrls))
}
319109
def url(self):
        
        if self._href is not None:
            return self._href
        if self.identifier:
            #  for some reason atlas does not use classifications here in the path when considering one classification
            path = '/'.join([self.parent.url.replace('classifications/', 'classficiation/'), self.identifier])
            return path
        raise exceptions.ClientError("Not able to determine object URL")
1056770
public static String getFullEventName(State state) {
    return Joiner.on('.').join(LineageEventBuilder.LIENAGE_EVENT_NAMESPACE, state.getProp(getKey(NAME_KEY)));
  }
802561
def url(self, **urlargs):
        '''
        '''
        if self.defaults:
            d = self.defaults.copy()
            d.update(urlargs)
            urlargs = d
        url = '/'.join(self._url_generator(urlargs))
        if not url:
            return '/'
        else:
            url = '/' + url
            return url if self.is_leaf else url + '/'
783072
function(state) {
      return state.url ? state : (state.parent ? state.parent.navigable : null);
    }
1078940
function (state) {
                if (!state.params) {
                    return state.url ? state.url.params : state.parent.params;
                }
                return state.params;
            }
562451
def url(self):
        
        path = None
        nodes = self.parents()
        while not nodes.empty():
            path = urljoin(path, nodes.get().path())
        return path
693072
def visible(self):
        
        context_state = api.content.get_view(context=self.context,
                                             request=self.request,
                                             name="plone_context_state")
        url = context_state.current_base_url()
        return url.endswith('@@sharing')