Returns the record for the complex definition to be used for database storage.
557232
def get_complex(self):
        ''''''
        d = dict(
            LName = self.lname,
            LShortName = self.lshortname,
            LHTMLName = self.lhtmlname,
            RName = self.rname,
            RShortName = self.rshortname,
            RHTMLName = self.rhtmlname,
            FunctionalClassID = self.functional_class_id,
            PPDBMFunctionalClassID = self.functional_class_id_ppdbm,
            PPDBMDifficulty = self.difficulty_ppdbm,
            IsWildType = self.is_wildtype,
            WildTypeComplexID = self.wildtype_complex,
            Notes = self.notes,
            Warnings = self.warnings,
        )
        if self.id:
            d['ID'] = self.id
        return d
552571
def get_definition(self):
        
        def_ = {
            "id": self.id,
            "name": self.name,
            "desc": self.desc
        }
        return def_
393956
protected Schema getFieldSchema(GenericRecord record, String schemaIdLocation) throws Exception {
    Optional<Object> schemaIdValue = AvroUtils.getFieldValue(record, schemaIdLocation);
    if (!schemaIdValue.isPresent()) {
      throw new Exception("Schema id with key " + schemaIdLocation + " not found in the record");
    }
    String schemaKey = String.valueOf(schemaIdValue.get());
    return (Schema) registry.getSchemaByKey(schemaKey);
  }
1267168
public int getRecordCount(Rec record)
    {
        int iRecordCount = 1;
        if ((this.getNodeType() == MessageRecordDesc.NON_UNIQUE_NODE)
            && (!this.isSingleDetail(record)))
                iRecordCount = Integer.MAX_VALUE;   // Until EOF
        return iRecordCount;
    }
924900
public RecordId getTailSolt() {
		Constant blkNum = getVal(OFFSET_TS_BLOCKID, BIGINT);
		Constant rid = getVal(OFFSET_TS_RID, INTEGER);
		BlockId bid = new BlockId(fileName, (Long) blkNum.asJavaVal());
		return new RecordId(bid, (Integer) rid.asJavaVal());
	}
536845
def read_record(self, dtype, shape=1, byteorder=None):
        """"""
        rec = numpy.rec
        try:
            record = rec.fromfile(self._fh, dtype, shape, byteorder=byteorder)
        except Exception:
            dtype = numpy.dtype(dtype)
            if shape is None:
                shape = self._size // dtype.itemsize
            size = product(sequence(shape)) * dtype.itemsize
            data = self._fh.read(size)
            record = rec.fromstring(data, dtype, shape, byteorder=byteorder)
        return record[0] if shape == 1 else record
22300
def get_record(self, domain, record):
        
        rec_id = utils.get_id(record)
        domain_id = utils.get_id(domain)
        uri = "/domains/%s/records/%s" % (domain_id, rec_id)
        resp, resp_body = self._retry_get(uri)
        resp_body["domain_id"] = domain_id
        return CloudDNSRecord(self, resp_body, loaded=False)
739556
def currentRecord( self ):
        
        if ( self.currentMode() == XOrbBrowserWidget.Mode.Detail ):
            return self.detailWidget().currentRecord()
        
        elif ( self.currentMode() == XOrbBrowserWidget.Mode.Thumbnail ):
            item = self.thumbnailWidget().currentItem()
            if ( isinstance(item, RecordListWidgetItem) ):
                return item.record()
            return None
        
        else:
            item = self.uiCardTREE.currentItem()
            widget = self.uiCardTREE.itemWidget(item, 0)
            if ( isinstance(widget, XAbstractCardWidget) ):
                return widget.record()
            
            return None
290167
def _get_record(self):
        
        if not self.pk:
            raise AJAXError(400, _('Invalid request for record.'))

        try:
            return self.model.objects.get(pk=self.pk)
        except self.model.DoesNotExist:
            raise AJAXError(404, _('%s with id of "%s" not found.') % (
                self.model.__name__, self.pk))
1252141
def currentRecord( self ):
        
        if self._currentRecord is None and self.isRequired():
            self._currentRecord = self.recordAt(self.currentIndex())
        return self._currentRecord
217325
def record(self):
        # type: () -> bytes
        '''
        
        '''
        if not self._initialized:
            raise pycdlibexception.PyCdlibInternalError('PD record not yet initialized!')

        return b'PD' + struct.pack('=BB', RRPDRecord.length(self.padding),
                                   SU_ENTRY_VERSION) + self.padding
365855
def define_record_methods record
      record.class_eval <<-RUBY, __FILE__, __LINE__ + 1
        def #{name};        tuple.fetch(:#{field}, nil)   end
        def #{name}= value; tuple.store(:#{field}, value) end
      RUBY
    end
63912
public String getReferenceRecordName()
    {
        if (m_recordReference != null)
            return this.getReferenceRecord().getTableNames(false);
        else
        {   // This code just takes a guess
            if (this.getClass().getName().indexOf("Field") != -1)
                return this.getClass().getName().substring(Math.max(0, this.getClass().getName().lastIndexOf('.') + 1), this.getClass().getName().indexOf("Field"));
            else if (this.getFieldName(false, false).indexOf("ID") != -1)
                return this.getFieldName(false, false).substring(0, this.getFieldName(false, false).indexOf("ID"));
            else
                this.getFieldName(false, false);
        }
        return Constants.BLANK;   // Never
    }
1085053
public Record getAltRecord()
    {
        Record recNext = this.getNextTable().getRecord();
        Iterator<BaseTable> tables = this.getTables();
        while (tables.hasNext())
        {
            Record recAlt = tables.next().getRecord();
            if (recAlt != recNext)
                return recAlt;
        }
        return recNext;
    }
1281853
public Record getRecord()
    {
        ContactField field = (ContactField)m_field;
        if (field.getContactTypeField() != null)
        {
            String strContactTypeID = field.getContactTypeField().toString();
            if (field.PROFILE_CONTACT_TYPE_ID.equals(strContactTypeID))
                return field.m_recProfile;
        }
        return m_record;
    }
185721
def shapeRecord(self, i=0):
        """"""
        i = self.__restrictIndex(i)
        return _ShapeRecord(shape=self.shape(i),
                                                        record=self.record(i))
1140406
public SemanticType.Record extractRecordType(SemanticType type, Environment environment,
			ReadWriteTypeExtractor.Combinator<SemanticType.Record> combinator, SyntacticItem item) {
		//
		if (type != null) {
			SemanticType.Record recordT = rwTypeExtractor.apply(type, environment, combinator);
			//
			if (recordT == null) {
				syntaxError(item, EXPECTED_RECORD);
			} else {
				return recordT;
			}
		}
		return null;
	}