Gets the page label dictionary to insert into the document.
@return the page label dictionary
358083
PdfDictionary getDictionary(PdfWriter writer) {
        try {
            return PdfNumberTree.writeTree(map, writer);
        }
        catch (IOException e) {
            throw new ExceptionConverter(e);
        }
    }
1341164
def dict(self):
        
        collection = dict(
            page=self.page,
            per_page=self.per_page,
            total_items=self.total_items,
            total_pages=self.total_pages,
            pagination=self.pagination,
            items=list(self.items)
        )
        return collection
1079255
public List<String> getLabels() {
        if (labels != null && !labels.isEmpty())
            return labels;
        else {
            List<String> result = new ArrayList<>();
            for (long x = 0; x < counter.get(); x++)
                result.add(formatLabel(x));
            return result;
        }
    }
137191
public String getPrintName()
  {
    JType []typeArgs = getActualTypeArguments();
    
    if (typeArgs.length == 0)
      return getRawClass().getPrintName();

    StringBuilder cb = new StringBuilder();
    cb.append(getRawClass().getPrintName());
    cb.append('<');
    for (int i = 0; i < typeArgs.length; i++) {
      if (i != 0)
        cb.append(',');
      
      cb.append(typeArgs[i].getPrintName());
    }
    
    cb.append('>');

    return cb.toString();
  }
1268868
def _to_dict(self):
        """"""
        _dict = {}
        if hasattr(self, 'document_id') and self.document_id is not None:
            _dict['document_id'] = self.document_id
        if hasattr(self, 'passage_score') and self.passage_score is not None:
            _dict['passage_score'] = self.passage_score
        if hasattr(self, 'passage_text') and self.passage_text is not None:
            _dict['passage_text'] = self.passage_text
        if hasattr(self, 'start_offset') and self.start_offset is not None:
            _dict['start_offset'] = self.start_offset
        if hasattr(self, 'end_offset') and self.end_offset is not None:
            _dict['end_offset'] = self.end_offset
        if hasattr(self, 'field') and self.field is not None:
            _dict['field'] = self.field
        return _dict
434679
def get_grade_entry_mdata():
    """"""
    return {
        'resource': {
            'element_label': {
                'text': 'resource',
                'languageTypeId': str(DEFAULT_LANGUAGE_TYPE),
                'scriptTypeId': str(DEFAULT_SCRIPT_TYPE),
                'formatTypeId': str(DEFAULT_FORMAT_TYPE),
            },
            'instructions': {
                'text': 'accepts an osid.id.Id object',
                'languageTypeId': str(DEFAULT_LANGUAGE_TYPE),
                'scriptTypeId': str(DEFAULT_SCRIPT_TYPE),
                'formatTypeId': str(DEFAULT_FORMAT_TYPE),
            },
            'required': False,
            'read_only': False,
            'linked': False,
            'array': False,
            'default_id_values': [''],
            'syntax': 'ID',
            'id_set': [],
        },
        'grade': {
            'element_label': {
                'text': 'grade',
                'languageTypeId': str(DEFAULT_LANGUAGE_TYPE),
                'scriptTypeId': str(DEFAULT_SCRIPT_TYPE),
                'formatTypeId': str(DEFAULT_FORMAT_TYPE),
            },
            'instructions': {
                'text': 'accepts an osid.id.Id object',
                'languageTypeId': str(DEFAULT_LANGUAGE_TYPE),
                'scriptTypeId': str(DEFAULT_SCRIPT_TYPE),
                'formatTypeId': str(DEFAULT_FORMAT_TYPE),
            },
            'required': False,
            'read_only': False,
            'linked': False,
            'array': False,
            'default_id_values': [''],
            'syntax': 'ID',
            'id_set': [],
        },
        'ignored_for_calculations': {
            'element_label': {
                'text': 'ignored for calculations',
                'languageTypeId': str(DEFAULT_LANGUAGE_TYPE),
                'scriptTypeId': str(DEFAULT_SCRIPT_TYPE),
                'formatTypeId': str(DEFAULT_FORMAT_TYPE),
            },
            'instructions': {
                'text': 'enter either true or false.',
                'languageTypeId': str(DEFAULT_LANGUAGE_TYPE),
                'scriptTypeId': str(DEFAULT_SCRIPT_TYPE),
                'formatTypeId': str(DEFAULT_FORMAT_TYPE),
            },
            'required': False,
            'read_only': False,
            'linked': False,
            'array': False,
            'default_boolean_values': [None],
            'syntax': 'BOOLEAN',
        },
        'score': {
            'element_label': {
                'text': 'score',
                'languageTypeId': str(DEFAULT_LANGUAGE_TYPE),
                'scriptTypeId': str(DEFAULT_SCRIPT_TYPE),
                'formatTypeId': str(DEFAULT_FORMAT_TYPE),
            },
            'instructions': {
                'text': 'enter a decimal value.',
                'languageTypeId': str(DEFAULT_LANGUAGE_TYPE),
                'scriptTypeId': str(DEFAULT_SCRIPT_TYPE),
                'formatTypeId': str(DEFAULT_FORMAT_TYPE),
            },
            'required': False,
            'read_only': False,
            'linked': False,
            'array': False,
            'default_decimal_values': [None],
            'syntax': 'DECIMAL',
            'decimal_scale': None,
            'minimum_decimal': None,
            'maximum_decimal': None,
            'decimal_set': [],
        },
        'gradebook_column': {
            'element_label': {
                'text': 'gradebook column',
                'languageTypeId': str(DEFAULT_LANGUAGE_TYPE),
                'scriptTypeId': str(DEFAULT_SCRIPT_TYPE),
                'formatTypeId': str(DEFAULT_FORMAT_TYPE),
            },
            'instructions': {
                'text': 'accepts an osid.id.Id object',
                'languageTypeId': str(DEFAULT_LANGUAGE_TYPE),
                'scriptTypeId': str(DEFAULT_SCRIPT_TYPE),
                'formatTypeId': str(DEFAULT_FORMAT_TYPE),
            },
            'required': False,
            'read_only': False,
            'linked': False,
            'array': False,
            'default_id_values': [''],
            'syntax': 'ID',
            'id_set': [],
        },
    }
399978
public String getPDFPageAnnotationName() {

    Properties mappings = input.getMappings();

    if (mappings != null) {
      return mappings.getProperty(MAPPING_PAGE_KEY,
              DEFAULT_PAGE_NUMBER_ANNOTATION_NAME);
    }

    return DEFAULT_PAGE_NUMBER_ANNOTATION_NAME;
  }
1040291
public String getLabelKey()
    {
        final StringBuilder keyStr = new StringBuilder();
        return keyStr.append(getStatusGroup().getName()).append("/Key.Status.").append(key).toString();
    }
163418
public String getSelectionInfo(){
		StringBuilder result = new StringBuilder();
		
		result.append( "SelectionInfo: "+this.getClass().toString() +"\n" );
		result.append( "Page:"+ CITInfo( pageHandling )+"\n" );
		result.append( "FirstParagraph:" +CITInfo( firstParagraphHandling )+"\n");
		for( String key: sectionHandling.keySet() ){
			final String uss = SectionType.USER_SECTION.toString();
			if( key.startsWith( uss ) )
				result.append(uss+"["+key.substring( uss.length() )+"]:\n");
			else
				result.append(key+":\n");
			
			result.append( SITInfo( sectionHandling.get(key))+"\n" );
		}
 		
		return result.toString();
	}
1300959
protected Label createTitleLabel() {
        Label label = new Label();
        label.setWrapText(true);
        label.setMinSize(0, 0);

        return label;
    }
36505
public String getLabelText() {
		String value = (String) getStateHelper().eval(PropertyKeys.labelText);
		return value;
	}
450748
def labels(self):
        
        return [self._labels.get(value) or text.pretty(key)
                for key, value in sorted(self.items(), key=lambda x: x[1])]
939044
public String getPrintName()
  {
    if (_typeArgs.length == 0)
      return _rawClass.getPrintName();

    StringBuilder cb = new StringBuilder();
    cb.append(_rawClass.getPrintName());
    cb.append('<');
    for (int i = 0; i < _typeArgs.length; i++) {
      if (i != 0)
        cb.append(',');
      
      cb.append(_typeArgs[i].getPrintName());
    }
    
    cb.append('>');

    return cb.toString();
  }
401010
def get_label(key):
    
    if key in rel:
        if mpl.rcParams['text.usetex']:
            return rel[key]['label_latex']
        else:
            return rel[key]['label_mpl']
    else:
        return key
574564
public Pair<int[][][][], int[][]> documentsToDataAndLabels(Collection<List<IN>> documents) {

    // first index is the number of the document
    // second index is position in the document also the index of the
    // clique/factor table
    // third index is the number of elements in the clique/window these features
    // are for (starting with last element)
    // fourth index is position of the feature in the array that holds them
    // element in data[i][j][k][m] is the index of the mth feature occurring in
    // position k of the jth clique of the ith document
    // int[][][][] data = new int[documentsSize][][][];
    List<int[][][]> data = new ArrayList<int[][][]>();

    // first index is the number of the document
    // second index is the position in the document
    // element in labels[i][j] is the index of the correct label (if it exists)
    // at position j in document i
    // int[][] labels = new int[documentsSize][];
    List<int[]> labels = new ArrayList<int[]>();

    int numDatums = 0;

    for (List<IN> doc : documents) {
      Pair<int[][][], int[]> docPair = documentToDataAndLabels(doc);
      data.add(docPair.first());
      labels.add(docPair.second());
      numDatums += doc.size();
    }

    System.err.println("numClasses: " + classIndex.size() + ' ' + classIndex);
    System.err.println("numDocuments: " + data.size());
    System.err.println("numDatums: " + numDatums);
    System.err.println("numFeatures: " + featureIndex.size());
    printFeatures();

    int[][][][] dataA = new int[0][][][];
    int[][] labelsA = new int[0][];

    return new Pair<int[][][][], int[][]>(data.toArray(dataA), labels.toArray(labelsA));
  }
494020
def dictionary(self):
        
        output = {}
        for i in range(self.topLevelItemCount() - 1):
            item = self.topLevelItem(i)
            output[nativestring(item.text(1))] = nativestring(item.text(2))
        return output
536246
public java.lang.String getLabel() {
        return (java.lang.String) getStateHelper().eval(PropertyKeys.label);

    }