/*
* Copyright 2003-2016 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package jetbrains.mps.generator.impl;
import jetbrains.mps.module.ReloadableModule;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.mps.openapi.model.SModelReference;
import org.jetbrains.mps.openapi.persistence.DataSourceListener;
import org.jetbrains.mps.openapi.persistence.MultiStreamDataSource;
import org.jetbrains.mps.openapi.persistence.datasource.DataSourceType;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Collections;
/**
* @author Artem Tikhomirov
*/
public class DeployedStreamManager implements ModelStreamManager {
private final SModelReference myModelReference;
private final DataSourceImpl myDataSource;
/*package*/ DeployedStreamManager(@NotNull SModelReference modelReference, @NotNull ReloadableModule module) {
myModelReference = modelReference;
myDataSource = new DataSourceImpl(module, modelReference.getName().getValue().replace('.', '/'));
}
@Override
public SModelReference getModel() {
return myModelReference;
}
@NotNull
@Override
public MultiStreamDataSource getOutputLocation() {
return myDataSource;
}
@Override
public MultiStreamDataSource getCachesLocation() {
return null;
}
// FIXME use MultiStreamDataSourceBase (extract our from PersistenceUtil)
private static class DataSourceImpl implements MultiStreamDataSource {
private final ReloadableModule myModule;
private final String myLocation;
DataSourceImpl(@NotNull ReloadableModule module, @NotNull String location) {
myModule = module;
myLocation = location;
}
@NotNull
@Override
public Iterable<String> getAvailableStreams() {
if (!isModuleClassLoaderAlive()) {
return Collections.emptyList();
}
String[] knownStreams = new String[] {"exports"};
ArrayList<String> rv = new ArrayList<String>(knownStreams.length);
for (String name : knownStreams) {
if (exists(name)) {
rv.add(name);
}
}
return rv;
}
@NotNull
@Override
public InputStream openInputStream(String name) throws IOException {
if (!isModuleClassLoaderAlive()) {
throw new IOException(String.format("Could not access model stream %s in module %s due to missing ClassLoader", name, myModule.getModuleName()));
}
if (exists(name)) {
final ClassLoader cl = myModule.getClassLoader();
assert cl != null;
return cl.getResourceAsStream(toResourceName(name));
}
throw new FileNotFoundException(String.format("Couldn't find model stream '%s' in module %s (at %s)", name, myModule.getModuleName(), myLocation));
}
@NotNull
@Override
public OutputStream openOutputStream(String name) throws IOException {
throw new UnsupportedOperationException();
}
@Override
public boolean delete(String name) {
throw new UnsupportedOperationException();
}
@NotNull
@Override
public String getLocation() {
return myLocation;
}
@Override
public void addListener(@NotNull DataSourceListener listener) {
// no-op
}
@Override
public void removeListener(@NotNull DataSourceListener listener) {
// no-op
}
@Override
public long getTimestamp() {
return 0;
}
@Override
public boolean isReadOnly() {
return true;
}
@Nullable
@Override
public DataSourceType getType() {
return null;
}
private boolean isModuleClassLoaderAlive() {
return myModule.getClassLoader() != null;
}
private String toResourceName(String shortName) {
return myLocation + '/' + shortName;
}
private boolean exists(String shortName) {
return null != myModule.getClassLoader().getResource(toResourceName(shortName));
}
}
}