Finds the owner of the specified lock (if any) among this node and its peers.  This answer
is not definitive, as the lock may be in the process of resolving.
559609
public String queryLock (NodeObject.Lock lock)
    {
        for (NodeObject nodeobj : getNodeObjects()) {
            if (nodeobj.locks.contains(lock)) {
                return nodeobj.nodeName;
            }
        }
        return null;
    }
327532
def get_all_project_owners(project_ids=None, **kwargs):
    


    projowner_qry = db.DBSession.query(ProjectOwner)

    if project_ids is not None:
       projowner_qry = projowner_qry.filter(ProjectOwner.project_id.in_(project_ids))

    project_owners_i = projowner_qry.all()

    return [JSONObject(project_owner_i) for project_owner_i in project_owners_i]
157418
public ServerBartender owner()
  {
    for (int i = 0; i < _owners.length; i++) {
      ServerBartender serverBar = server(i);
      
      if (serverBar != null && serverBar.isUp()) {
        return serverBar;
      }
    }

    return null;
  }
281846
@Override
    public ILockableEntityGroup findGroupWithLock(String key, String owner, int secs)
            throws GroupsException {

        throwExceptionIfNotInternallyManaged();

        Class groupType = ICompositeGroupService.GROUP_ENTITY_TYPE;
        try {
            IEntityLock lock =
                    (secs == 0)
                            ? EntityLockService.instance().newWriteLock(groupType, key, owner)
                            : EntityLockService.instance()
                                    .newWriteLock(groupType, key, owner, secs);

            ILockableEntityGroup group = groupFactory.findLockable(key);
            if (group == null) {
                lock.release();
            } else {
                group.setLock(lock);
                group.setLocalGroupService(this);
            }

            return group;
        } catch (LockingException le) {
            throw new GroupsException("Problem getting lock for group " + key, le);
        }
    }
306027
@Override
	public final Principal getOwnerNode() {

		if (cachedOwnerNode == null) {

			final Ownership ownership = getIncomingRelationshipAsSuperUser(PrincipalOwnsNode.class);
			if (ownership != null) {

				Principal principal = ownership.getSourceNode();
				cachedOwnerNode = (Principal) principal;
			}
		}

		return cachedOwnerNode;
	}
375764
private boolean ownerCanReadTable(String ownerId, String table) {
        return _internalAuthorizer.hasPermissionById(ownerId, getReadPermission(table));
    }
603822
public static synchronized @CheckForNull PermissionGroup get(Class owner) {
        for (PermissionGroup g : PERMISSIONS) {
            if (g.owner == owner) {
                return g;
            }
        }
        return null;
    }
1133791
def is_owned_by_current_user(self):
        

        from bambou.nurest_root_object import NURESTRootObject
        root_object = NURESTRootObject.get_default_root_object()
        return self._owner == root_object.id
1329761
public void setOwner(Graph<DataT, NodeT> ownerGraph) {
        if (this.ownerGraph != null) {
            throw new RuntimeException("Changing owner graph is not allowed");
        }
        this.ownerGraph = ownerGraph;
    }
97472
public java.lang.String getOwner() {
    java.lang.Object ref = owner_;
    if (ref instanceof java.lang.String) {
      return (java.lang.String) ref;
    } else {
      com.google.protobuf.ByteString bs = 
          (com.google.protobuf.ByteString) ref;
      java.lang.String s = bs.toStringUtf8();
      if (bs.isValidUtf8()) {
        owner_ = s;
      }
      return s;
    }
  }
1001071
static Node getBestLValueOwner(@Nullable Node lValue) {
    if (lValue == null || lValue.getParent() == null) {
      return null;
    }
    if (mayBeObjectLitKey(lValue) || lValue.isComputedProp()) {
      return getBestLValue(lValue.getParent());
    } else if (isGet(lValue)) {
      return lValue.getFirstChild();
    }

    return null;
  }
368831
def is_locked(lock):
    
    if hasattr(lock, 'locked'):
        return lock.locked()
    elif hasattr(lock, '_is_owned'):
        return lock._is_owned()
    else:
        raise TypeError('expecting Lock/RLock')
459304
def owners(self):
        """"""
        result = set()
        for role in self._OWNER_ROLES:
            for member in self._bindings.get(role, ()):
                result.add(member)
        return frozenset(result)
318668
public static ILockableEntityGroup findLockableGroup(String key, String lockOwner)
            throws GroupsException {
        LOGGER.trace("Invoking findLockableGroup for key='{}', lockOwner='{}'", key, lockOwner);
        return instance().ifindLockableGroup(key, lockOwner);
    }
214576
private boolean canAccessPrivateMembers( IType ownersClass, IType whosAskin )
  {
    return getOwnersType() == whosAskin ||
           getTopLevelTypeName( whosAskin ).equals( getTopLevelTypeName( ownersClass ) );
  }
1351924
@Override
  public int owner(int hash)
  {
    NodePodAmp delegate = delegate();
    
    if (delegate != null) {
      return delegate().owner(hash);
    }
    else {
      return 0;
    }
  }
746047
public void addOwner(String owner) {
        if (this.owners == null) {
            this.owners = new Hashtable<String, String>();
        }
        this.owners.put(owner, owner);
    }