{@inheritDoc}

@see nl.pvanassen.ns.handle.Handle#getModel(java.io.InputStream)
19816
@Override
    public ReisMogelijkheden getModel(InputStream stream) {
        SimpleDateFormat format = new SimpleDateFormat(NsApi.DATETIME_FORMAT);
        try {
            Xml xml = Xml.getXml(stream, "ReisMogelijkheden");
            List<ReisMogelijkheid> reisMogelijkheden = new ArrayList<>(xml.children("ReisMogelijkheid")
                    .size());
            for (Xml reisMogelijkheidXml : xml.children("ReisMogelijkheid")) {
                List<Melding> meldingen = new LinkedList<>();
                if (reisMogelijkheidXml.isPresent("Melding")) {
                    for (Xml meldingXml : reisMogelijkheidXml.children("Melding")) {
                        String id = meldingXml.child("Id").content();
                        boolean ernstig = Boolean.parseBoolean(meldingXml.child("Ernstig").content());
                        String text = meldingXml.child("Text").content();
                        meldingen.add(new Melding(id, ernstig, text));
                    }
                }
                int aantalOverstappen = Integer.parseInt(reisMogelijkheidXml.child("AantalOverstappen").content());
                int geplandeReisTijdMinuten = getReistijdInMinuten(reisMogelijkheidXml.child("GeplandeReisTijd")
                        .content());
                int actueleReisTijdMinuten = getReistijdInMinuten(reisMogelijkheidXml.child("ActueleReisTijd")
                        .content());
                boolean optimaal = true;
                if (reisMogelijkheidXml.isPresent("Optimaal")) {
                    optimaal = Boolean.parseBoolean(reisMogelijkheidXml.child("Optimaal").content());
                }
                Date geplandeVertrekTijd = format.parse(reisMogelijkheidXml.child("GeplandeVertrekTijd").content());
                Date actueleVertrekTijd = format.parse(reisMogelijkheidXml.child("ActueleVertrekTijd").content());
                Date geplandeAankomstTijd = format.parse(reisMogelijkheidXml.child("GeplandeAankomstTijd").content());
                Date actueleAankomstTijd = format.parse(reisMogelijkheidXml.child("ActueleAankomstTijd").content());
                String aankomstVertraging = reisMogelijkheidXml.child("AankomstVertraging").content();
                String status = reisMogelijkheidXml.child("Status").content();
                List<ReisDeel> reisDelen = new ArrayList<>(reisMogelijkheidXml.children("ReisDeel").size());
                for (Xml reisDeelXml : reisMogelijkheidXml.children("ReisDeel")) {
                    String reisSoort = reisDeelXml.attr("reisSoort");
                    String vervoerder = reisDeelXml.child("Vervoerder").content();
                    String vervoerType = reisDeelXml.child("VervoerType").content();
                    int ritNummer = Integer.parseInt(reisDeelXml.child("RitNummer").content());
                    String statusReisdeel = reisDeelXml.child("Status").content();
                    String geplandeStoringId = reisDeelXml.child("GeplandeStoringId").content();
                    String ongeplandeStoringId = reisDeelXml.child("OngeplandeStoringId").content();
                    List<ReisStop> reisStops = new ArrayList<>(reisDeelXml.children("ReisStop").size());
                    for (Xml reisStopXml : reisDeelXml.children("ReisStop")) {
                        String naam = reisStopXml.child("Naam").content();
                        Date tijd = format.parse(reisStopXml.child("Tijd").content());
                        String spoor = reisStopXml.child("Spoor").content();
                        boolean gewijzigdVertrekspoor = false;
                        if (spoor != null) {
                            gewijzigdVertrekspoor = Boolean.parseBoolean(reisStopXml.child("Spoor").attr("wijziging"));
                        }
                        reisStops.add(new ReisStop(naam, tijd, spoor, gewijzigdVertrekspoor));
                    }
                    List<String> reisDetails = new ArrayList<>(reisDeelXml.child("Reisdetails")
                            .children("Reisdetail").size());
                    for (Xml reisDetailXml : reisDeelXml.child("Reisdetails").children("Reisdetail")) {
                        reisDetails.add(reisDetailXml.content());
                    }
                    reisDelen.add(new ReisDeel(reisSoort, vervoerder, vervoerType, ritNummer, statusReisdeel,
                            reisStops, ongeplandeStoringId, geplandeStoringId, reisDetails));
                }
                reisMogelijkheden.add(new ReisMogelijkheid(meldingen, aantalOverstappen, geplandeReisTijdMinuten,
                        actueleReisTijdMinuten, aankomstVertraging, optimaal, geplandeVertrekTijd, actueleVertrekTijd,
                        geplandeAankomstTijd, actueleAankomstTijd, status, reisDelen));
            }
            return new ReisMogelijkheden(reisMogelijkheden);
        }
        catch (ParseException e) {
            logger.error("Error parsing stream to actuele vertrektijden", e);
            throw new NsApiException("Error parsing stream to actuele vertrektijden", e);
        }
    }
872570
public SimpleMisoSceneModel parseScene (InputStream in)
        throws IOException, SAXException
    {
        _model = null;
        _digester.push(this);
        _digester.parse(in);
        return _model;
    }
1004598
public String model() throws CommandExecutionException {
        JSONObject in = info();
        if (in == null) throw new CommandExecutionException(CommandExecutionException.Error.INVALID_RESPONSE);
        return in.optString("model");
    }
218358
protected String onGetObject(final IModel<T> rowModel)
	{
		final IModel<?> propertyModel = DateColumn.this.getDataModel(rowModel);
		final Date value = (Date)propertyModel.getObject();
		if (value == null) {
			return "";
		}
		final SimpleDateFormat format = new SimpleDateFormat(dateFormat);
		return format.format(value);
	}
8845
static void exportModel() throws Exception {
    HttpClient client = new HttpClient();
    GetMethod get = new GetMethod(URL + "/2/ExportModel.json?model=MyInitialNeuralNet");
    int status = client.executeMethod(get);
    if( status != 200 )
      throw new Exception(get.getStatusText());
    JsonObject response = (JsonObject) new JsonParser().parse(new InputStreamReader(get.getResponseBodyAsStream()));
    JsonElement model = response.get("model");
    JsonWriter writer = new JsonWriter(new FileWriter(JSON_FILE));
    writer.setLenient(true);
    writer.setIndent("  ");
    Streams.write(model, writer);
    writer.close();
    get.releaseConnection();
  }
936506
public static Asset readValue(InputStream inputStream) throws IOException, BadVersionException {
        return DataModelSerializer.deserializeObject(inputStream, Asset.class);
    }
1210804
@Override
    public Prijzen getModel(InputStream stream) {
        Map<String, VervoerderKeuze> vervoerderKeuzes = new HashMap<>();
        Xml xml = Xml.getXml(stream, "VervoerderKeuzes");
        for (Xml vervoerderKeuze : xml.children("VervoerderKeuze")) {
            String vervoerderKeuzeNaam = vervoerderKeuze.attr("naam");
            int tariefEenheden = Integer.parseInt(vervoerderKeuze.child("Tariefeenheden").content());
            Map<String, ReisType> reisTypes = new HashMap<>();
            for (Xml reisTypeXml : vervoerderKeuze.children("ReisType")) {
                String reisTypeNaam = reisTypeXml.attr("name");
                Map<Integer, ReisKlasse> reisKlassen = new HashMap<>();
                for (Xml reisKlasseXml : reisTypeXml.children("ReisKlasse")) {
                    int klasse = Integer.parseInt(reisKlasseXml.attr("klasse"));
                    //  <Prijsdeel vervoerder="NS" prijs="47.20" naar="GDM" van="RTD"/>
                    List<Prijsdeel> prijsdelen = new LinkedList<>();
                    for (Xml prijsdeelXml : reisKlasseXml.children("Prijsdeel")) {
                        prijsdelen.add(new Prijsdeel(prijsdeelXml.attr("vervoerder"), new BigDecimal(prijsdeelXml.attr("prijs")), prijsdeelXml.attr("van"), prijsdeelXml.attr("naar")));
                    }
                    BigDecimal totaal = new BigDecimal(reisKlasseXml.child("Totaal").content());
                    Map<String, BigDecimal> kortingprijzen = new HashMap<>();
                    for (Xml kortingsPrijsXml : reisKlasseXml.child("Korting").children("Kortingsprijs")) {
                        kortingprijzen.put(kortingsPrijsXml.attr("name"), new BigDecimal(kortingsPrijsXml.attr("prijs")));
                    }
                    reisKlassen.put(klasse, new ReisKlasse(klasse, prijsdelen, totaal, Collections.unmodifiableMap(kortingprijzen)));
                }
                reisTypes.put(reisTypeNaam, new ReisType(reisTypeNaam, Collections.unmodifiableMap(reisKlassen)));
            }
            vervoerderKeuzes.put(vervoerderKeuzeNaam, new VervoerderKeuze(vervoerderKeuzeNaam, tariefEenheden, Collections.unmodifiableMap(reisTypes)));
        }
        return new Prijzen(Collections.unmodifiableMap(vervoerderKeuzes));
    }
98094
@Override
    public Model read(Configuration config) {
        String name = config.getName();
        Descriptor desc = getDescriptor();
        if (IMPLEMENTATION_BPM.equals(name)) {
            return new V1BPMComponentImplementationModel(config, desc);
        } else if (OPERATION.equals(name)) {
            return new V1BPMOperationModel(config, desc);
        }
        return super.read(config);
    }
748222
public static List<Asset> readValues(InputStream inputStream) throws IOException {
        return DataModelSerializer.deserializeList(inputStream, Asset.class);
    }
113543
public KerasModelBuilder modelJsonInputStream(InputStream modelJsonInputStream) throws IOException {
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        IOUtils.copy(modelJsonInputStream, byteArrayOutputStream);
        this.modelJson = new String(byteArrayOutputStream.toByteArray());
        return this;
    }
1372325
public static Document getDocument(InputStream inputStream) {
        Document result = null;

        try {
            // memory optimization over minor performance sacrifice
            synchronized (XmlRepositoryFactory.class) {
                if (documentBuilder == null) {
                    documentBuilder = builderFactory.newDocumentBuilder();
                }

                result = documentBuilder.parse(inputStream);
            }
        } catch (ParserConfigurationException ex) {
            throw new MjdbcRuntimeException(ex);
        } catch (SAXException ex) {
            throw new MjdbcRuntimeException(ex);
        } catch (IOException ex) {
            throw new MjdbcRuntimeException(ex);
        }

        return result;
    }
507068
@Override
    public Optional<SoyMapData> toSoyMap(@Nullable final Object model) throws Exception {
        if (model instanceof SoyMapData) {
            return Optional.of((SoyMapData) model);
        }
        if (model instanceof Map) {
            return Optional.of(new SoyMapData(model));
        }

        return Optional.of(new SoyMapData());
    }
231202
private Model readModel(final InputStream pomStream) throws MojoExecutionException {
        Reader reader = null;
        try {
            reader = ReaderFactory.newXmlReader(pomStream);
            return new MavenXpp3Reader().read(reader);
        } catch (FileNotFoundException e) {
            throw new MojoExecutionException("File not found " + pomFile, e);
        } catch (IOException e) {
            throw new MojoExecutionException("Error reading POM " + pomFile, e);
        } catch (XmlPullParserException e) {
            throw new MojoExecutionException("Error parsing POM " + pomFile, e);
        } finally {
            IOUtil.close(reader);
        }
    }
805169
public static ModelLoader load(InputStream stream) throws IOException {
        JsonNode tree = MAPPER.readTree(stream);
        JsonNode version = tree.get("FormatVersion");
        if (version == null || !version.isObject()) {
            throw new IllegalStateException("No FormatVersion found");
        }

        JsonNode major = version.get("Major");
        if (major == null || !major.isNumber()) {
            throw new IllegalStateException("No Major version found");
        }

        int majorVersion = major.asInt();

        switch (majorVersion) {
        case 1:
            return new ModelLoader(loadV1Model(tree, version));

        default:
            throw new IllegalStateException(
                    "Unknown major version " + majorVersion + ". Perhaps "
                    + "you need a newer version of the resources runtime?");
        }
    }
798655
public static <T> List<T> readValues(InputStream inputStream, Class<T> type) throws IOException {
        return DataModelSerializer.deserializeList(inputStream, type);
    }
233830
@SuppressWarnings("unchecked") // yaml.load API returns raw Map
  public static Map<String, Object> loadStream(InputStream inputStream) {
    LOG.fine("Reading config stream");

    Yaml yaml = new Yaml();
    Map<Object, Object> propsYaml = (Map<Object, Object>) yaml.load(inputStream);
    LOG.fine("Successfully read config");

    Map<String, Object> typedMap = new HashMap<>();
    for (Object key: propsYaml.keySet()) {
      typedMap.put(key.toString(), propsYaml.get(key));
    }

    return typedMap;
  }
735255
public TransformGroup getModel(Object object, TransformGroup model) {

        Failure failure = (Failure) object;
//        model = new TransformGroup();

//        Color3f colour;
//        Sphere s = new Sphere(diameter);
//        Cone s = new Cone(diameter, diameter);
//        ColorCube s = new ColorCube(diameter);
        
//        colour = new Color3f(Color.black);

        int FONT_SIZE = 50;
        Font labelFont = new Font("SansSerif", Font.BOLD, FONT_SIZE);
        double labelScale = 1.0;
        double SCALING_MODIFIER = 1.0 / 5.0; 

//        model.removeAllChildren();
//        Appearance appearance = new Appearance();
//        appearance.setColoringAttributes(new ColoringAttributes(colour,
//                ColoringAttributes.SHADE_GOURAUD));
//        Material m = new Material();
//        m.setAmbientColor(colour);
//        m.setEmissiveColor(0f, 0f, 0f);
//        m.setDiffuseColor(colour);
//        m.setSpecularColor(1f, 1f, 1f);
//        m.setShininess(128f);
//        appearance.setMaterial(m);
//        s.setAppearance(appearance);
//        model.addChild(s);
//        model.setName(failure.getID());
//        clearPickableFlags(model);
//        model.setPickable(true);
        
        


        // draw the device labels if the user wants
//        Transform3D offset = new Transform3D();
//        offset.setTranslation(new Vector3d(5+diameter/2,5+diameter/2,5+diameter/2));
//        Transform3D trans = offset;
        String str = failure.getID();
        com.sun.j3d.utils.geometry.Text2D text = new com.sun.j3d.utils.geometry.Text2D(
                str, new Color3f(Color.black), labelFont.getFamily(),
                labelFont.getSize(), labelFont.getStyle());
        text.setRectangleScaleFactor((float) (labelScale * SCALING_MODIFIER));

        // text = new Shape3D(new Text3D(labelFont3D, ""));

        OrientedShape3D o3d = new OrientedShape3D(text.getGeometry(),
                text.getAppearance(), OrientedShape3D.ROTATE_ABOUT_POINT,
                new Point3f(0, 0, 0));
        o3d.setCapability(Shape3D.ALLOW_APPEARANCE_WRITE); // may need to change
                                                           // the appearance
                                                           // (see below)
        o3d.setCapability(Shape3D.ALLOW_GEOMETRY_WRITE); // may need to change
                                                         // the geometry (see
                                                         // below)
        o3d.clearCapabilityIsFrequent(Shape3D.ALLOW_APPEARANCE_WRITE);
        o3d.clearCapabilityIsFrequent(Shape3D.ALLOW_GEOMETRY_WRITE);

        // make the offset TransformGroup
        model = new TransformGroup();
        model.setCapability(TransformGroup.ALLOW_CHILDREN_READ);
        model.setCapability(TransformGroup.ALLOW_TRANSFORM_READ);
        model.setCapability(TransformGroup.ALLOW_TRANSFORM_WRITE);
        model.clearCapabilityIsFrequent(TransformGroup.ALLOW_CHILDREN_READ);
//        model.setTransform(trans);
        model.setUserData(str);

        // the label shouldn't be pickable -- we'll turn this off in the
        // TransformGroup
        clearPickableFlags(model);
        model.addChild(o3d); // Add label to the offset TransformGroup
//        model.addChild(model);

        return model;
    }