Read creator.

@param tv the tv
177620
private void readCreator(TagValue tv) {
    int creatorSignature = tv.getBytesBigEndian(4, 4);
    creator = IccProfileCreators.getIccProfile(creatorSignature);
  }
1111520
public void open() {
		// generate a new unique identifier for the channel
		this.ssrc = SsrcGenerator.generateSsrc();
		this.statistics.setSsrc(this.ssrc);
		this.open = true;
		
		if(logger.isDebugEnabled()) {
			logger.debug(this.mediaType + " channel " + this.ssrc + " is open");
		}
	}
1022496
protected void readCode()
        throws InstallationException
    {
        try {
            final char[] buf = new char[1024];

            final InputStream input = getUrl().openStream();

            final Reader reader = new InputStreamReader(input, AbstractSourceImporter.ENCODING);
            int length;
            while ((length = reader.read(buf)) > 0) {
                this.code.append(buf, 0, length);
            }
            reader.close();
        } catch (final IOException e) {
            throw new InstallationException("Could not read source code from url '" + this.url + "'.", e);
        }
    }
461519
private synchronized void setCreator(ObjectValue newCreator)
	{
		// Do not set the creator if created by the system class. The System contains
		// fields with references to Thread instances which are not Serializable and
		// will fail a deep copy with a NotSerializableExpection for Thread
		if (newCreator != null
				&& newCreator.type.getClassdef() instanceof ASystemClassDefinition)
		{
			return;
		}
		// establish transitive reference
		newCreator.addChild(this);
	}
926626
private void readVersion(TagValue tv) {
    int maj = tv.getBytesBigEndian(8, 1); // Major version
    int min = (tv.getBytesBigEndian(9, 1) & 0xF0) >> 4; // Minor version (in the first 4 bits of the
                                                        // byte)
    version = maj + "." + min;
  }
1224143
public FTSeries getTvArtwork(String id) throws FanartTvException {
        URL url = ftapi.getImageUrl(BaseType.TV, id);
        String page = requestWebPage(url);

        FTSeries series = null;

        try {
            series = mapper.readValue(page, FTSeries.class);
        } catch (IOException ex) {
            throw new FanartTvException(ApiExceptionType.MAPPING_FAILED, "Failed to get data for ID " + id, url, ex);
        }

        if (series.isError()) {
            throw new FanartTvException(ApiExceptionType.ID_NOT_FOUND, series.getErrorMessage());
        }

        return series;
    }
1361216
private static int getEpisodeValue(Element eEpisode, String key) {
        int episodeValue;
        try {
            String value = DOMHelper.getValueFromElement(eEpisode, key);
            episodeValue = NumberUtils.toInt(value, 0);
        } catch (WebServiceException ex) {
            LOG.trace("Failed to read episode value", ex);
            episodeValue = 0;
        }

        return episodeValue;
    }
1306070
public <P>JsonModelBuilder<T> rm(JsonPropertyBuilderCreator<T> creator) {
		rmSub(creator.<P> get());
		return this;
	}
265001
@Override
  public Reader create(Reader input) {
    String configuration = null;
    try {
      return create(input, configuration);
    } catch (IOException e) {
      log.debug(e);
      return null;
    }
  }
299477
private void renderEpisodesHeader(TvShowViewModel tvShow) {
    episodesListView.removeHeaderView(header);
    header = (TextView) getLayoutInflater().inflate(R.layout.episode_header, null);
    header.setText(tvShow.getTitle().toUpperCase() + " - SEASON 1");
    episodesListView.setAdapter(null);
    episodesListView.addHeaderView(header);
    episodesListView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
      @Override public void onItemClick(AdapterView<?> adapterView, View view, int position,
          long id) {
        if (tvShowSelected != null) {
          if (position > 0) {
            EpisodeViewModel episodeViewModel = tvShowSelected.getEpisodes().get(position - 1);
            Toast.makeText(getBaseContext(),
                tvShowSelected.getTitle() + " - " + episodeViewModel.getTitle(), Toast.LENGTH_LONG)
                .show();
          }
        }
      }
    });
  }
268300
def _call_custom_creator(self, config):
        
        creator = self._custom_creators[config['driver']](config)

        if isinstance(creator, Store):
            creator = self.repository(creator)

        if not isinstance(creator, Repository):
            raise RuntimeError('Custom creator should return a Repository instance.')

        return creator
116954
private void readInput() {
        if (buf.limit() == buf.capacity())
            makeSpace();

        // Prepare to receive data
        int p = buf.position();
        buf.position(buf.limit());
        buf.limit(buf.capacity());

        int n = 0;
        try {
            n = source.read(buf);
        } catch (IOException ioe) {
            lastException = ioe;
            n = -1;
        }

        if (n == -1) {
            sourceClosed = true;
            needInput = false;
        }

        if (n > 0)
            needInput = false;

        // Restore current position and limit for reading
        buf.limit(buf.position());
        buf.position(p);
        // Android-changed: The matcher implementation eagerly calls toString() so we'll have
        // to update its input whenever the buffer limit, position etc. changes.
        matcher.reset(buf);
    }
496269
private void initialize() {
        width = getContext().getResources().getDimensionPixelSize(R.dimen.default_width);
        maximize = false;
        adapter = new DividableGridAdapter(getContext(), Style.LIST, width);
        super.setOnShowListener(createOnShowListener());
    }
75236
protected void initBroadcastInputReaders() throws Exception {
		final int numBroadcastInputs = this.config.getNumBroadcastInputs();
		final MutableReader<?>[] broadcastInputReaders = new MutableReader<?>[numBroadcastInputs];

		int currentReaderOffset = config.getNumInputs();

		for (int i = 0; i < this.config.getNumBroadcastInputs(); i++) {
			//  ---------------- create the input readers ---------------------
			// in case where a logical input unions multiple physical inputs, create a union reader
			final int groupSize = this.config.getBroadcastGroupSize(i);
			if (groupSize == 1) {
				// non-union case
				broadcastInputReaders[i] = new MutableRecordReader<IOReadableWritable>(
						getEnvironment().getInputGate(currentReaderOffset),
						getEnvironment().getTaskManagerInfo().getTmpDirectories());
			} else if (groupSize > 1){
				// union case
				InputGate[] readers = new InputGate[groupSize];
				for (int j = 0; j < groupSize; ++j) {
					readers[j] = getEnvironment().getInputGate(currentReaderOffset + j);
				}
				broadcastInputReaders[i] = new MutableRecordReader<IOReadableWritable>(
						new UnionInputGate(readers),
						getEnvironment().getTaskManagerInfo().getTmpDirectories());
			} else {
				throw new Exception("Illegal input group size in task configuration: " + groupSize);
			}

			currentReaderOffset += groupSize;
		}
		this.broadcastInputReaders = broadcastInputReaders;
	}
748249
@Override
    public void onCreate(Bundle savedInstanceState) {
        setContentView(R.layout.about);
        TextView tv = (TextView) findViewById(R.id.legal_text);
        tv.setText(readRawTextFile(R.raw.legal));
        tv = (TextView) findViewById(R.id.info_text);
        tv.setText(Html.fromHtml(readRawTextFile(R.raw.info)));
        tv.setLinkTextColor(Color.WHITE);
        Linkify.addLinks(tv, Linkify.ALL);
    }
654056
public OmdbBuilder setTypeEpisode() {
        if (!ResultType.isDefault(ResultType.EPISODE)) {
            params.add(Param.RESULT, ResultType.EPISODE);
        }
        return this;
    }
680982
public static <T extends XSerializable> T parseItem(XElement item, Supplier<T> creator) {
        T result = creator.get();
        result.load(item);
        return result;
    }