gets a reference to the machines object
344671
def machines(self):
        """"""
        if self._resources is None:
            self.__init()
        if "machines" in self._resources:
            url = self._url + "/machines"
            return _machines.Machines(url,
                                      securityHandler=self._securityHandler,
                                      initialize=False,
                                      proxy_url=self._proxy_url,
                                      proxy_port=self._proxy_port)
        else:
            return None
1138441
protected function getMachineToMachine() {
        if (!$this->_machineToMachine) {
            $this->_machineToMachine = new MachineToMachineList(
                $this->version,
                $this->solution['accountSid'],
                $this->solution['countryCode']
            );
        }

        return $this->_machineToMachine;
    }
97512
function parseMachines(response) {
  let entities = {};
  Object.keys(response).forEach(key => {
    entities[key] = parseMachine(response[key]);
  });
  return entities;
}
1333068
def vb_get_machine(name, **kwargs):
    '''
    
    '''
    vbox = vb_get_box()
    machine = vbox.findMachine(name)
    return vb_xpcom_to_attribute_dict(machine, 'IMachine', **kwargs)
807843
@Override
	public final Reference getReference() throws NamingException
    {
    	Reference ref = new Reference(getClass().getName(),JNDIObjectFactory.class.getName(),null);
    	ref.add(new StringRefAddr("providerURL",getProviderURL()));
    	if (clientID != null)
    		ref.add(new StringRefAddr("clientID",clientID));
    	
    	return ref;
    }
709912
def _get_reference(self):
        
        super()._get_reference()
        self.hole_body_id = self.sim.model.body_name2id("hole")
        self.cyl_body_id = self.sim.model.body_name2id("cylinder")
1247234
def get instance_reference, keys = nil
    if keys
      namespace = keys.delete(:namespace) || "root/cimv2"
      instance_reference = Sfcc::Cim::ObjectPath.new(namespace, instance_reference)
      keys.each do |k,v|
        instance_reference.add_key k, v
      end
    end
    puts "@client.get #{instance_reference.class}..." if Wbem.debug
    case instance_reference
    when Sfcc::Cim::ObjectPath
      get_by_objectpath instance_reference
    when String
      get_by_objectpath CimxmlClient.parse_object_path(instance_reference)
    else
      raise "Unsupported Wbem::get #{instance_reference.class}"
    end
  end
358124
def get_referenced_object(self):
        

        if self._UserPerson is not None:
            return self._UserPerson

        if self._UserCompany is not None:
            return self._UserCompany

        raise exception.BunqException(self._ERROR_NULL_FIELDS)
42647
def handle_machines(changeset):
    """"""
    machines = sorted(changeset.bundle.get('machines', {}).items())
    for machine_name, machine in machines:
        if machine is None:
            # We allow the machine value to be unset in the YAML.
            machine = {}
        record_id = 'addMachines-{}'.format(changeset.next_action())
        changeset.send({
            'id': record_id,
            'method': 'addMachines',
            'args': [
                {
                    'series': machine.get('series', ''),
                    'constraints': machine.get('constraints', ''),
                },
            ],
            'requires': [],
        })
        changeset.machines_added[str(machine_name)] = record_id
        if 'annotations' in machine:
            changeset.send({
                'id': 'setAnnotations-{}'.format(changeset.next_action()),
                'method': 'setAnnotations',
                'args': [
                    '${}'.format(record_id),
                    'machine',
                    machine['annotations'],
                ],
                'requires': [record_id],
            })
    return handle_relations
265589
def machines(self, id=None, name=None, search=None):
        
        if self._machines is None:
            self._machines = {}
            self._list_machines()

        if id:
            return [self._machines[machine_id] for machine_id in self._machines.keys()
                    if str(id) == str(self._machines[machine_id].id)]
        elif name:
            return [self._machines[machine_id] for machine_id in self._machines.keys()
                    if name == self._machines[machine_id].name]
        elif search:
            return [self._machines[machine_id] for machine_id in self._machines.keys()
                    if str(search) == str(self._machines[machine_id].name)
                    or str(search) == str(self._machines[machine_id].id)]
        else:
            return [self._machines[machine_id] for machine_id in self._machines.keys()]
756202
def readReference(self):
        
        idx = self.stream.read_ushort()
        o = self.context.getObject(idx)

        if o is None:
            raise pyamf.ReferenceError('Unknown reference %d' % (idx,))

        return o
431304
def get_object(offset)
      io = to_shm_io
      io.seek(offset)
      Marshal.load(io)
    end
173912
def get_machine(self, key):
        
        h = self.hash(key)

        # edge case where we cycle past hash value of 1 and back to 0.
        if h > self.hash_tuples[-1][2]:
            return self.hash_tuples[0][0]

        hash_values = map(lambda x: x[2], self.hash_tuples)
        index = bisect.bisect_left(hash_values, h)
        return self.hash_tuples[index][0]
205210
def get_ref(cls, state, obj_alloc_id, field_class_name, field_name, field_type):
        
        # resolve field
        field_class = state.javavm_classloader.get_class(field_class_name)
        field_id = resolve_field(state, field_class, field_name, field_type)
        # return field ref
        return cls.from_field_id(obj_alloc_id, field_id)
123786
def this_machine(self, machineid=None):
        
        if machineid is None:
            machineid = _id128.get_machine().hex
        else:
            machineid = getattr(machineid, 'hex', machineid)
        self.add_match(_MACHINE_ID=machineid)
1061109
def as_machine(self):
        
        if self.node_type != NodeType.MACHINE:
            raise ValueError(
                'Cannot convert to `Machine`, node_type is not a machine.')
        return self._origin.Machine(self._data)
716537
def _get_reference(self):
        
        super()._get_reference()
        self.cube_body_id = self.sim.model.body_name2id("cube")
        self.l_finger_geom_ids = [
            self.sim.model.geom_name2id(x) for x in self.gripper.left_finger_geoms
        ]
        self.r_finger_geom_ids = [
            self.sim.model.geom_name2id(x) for x in self.gripper.right_finger_geoms
        ]
        self.cube_geom_id = self.sim.model.geom_name2id("cube")