id
stringlengths 7
14
| text
stringlengths 1
106k
|
|---|---|
590532_2
|
protected static long getNumericType(String raw) {
if (raw.contains(RemoteParticipant.RemoteParticipant_TYPE_CALL)) {
return TYPE_CALL;
} else if (raw.contains(RemoteParticipant.RemoteParticipant_TYPE_CONFERENCE)) {
return TYPE_CONFERENCE;
} else if (raw.contains(RemoteParticipant.RemoteParticipant_TYPE_DIALOG)) {
return TYPE_DIALOG;
}
return 0;
}
|
590532_3
|
protected static String shorten(BigInteger number) {
StringBuilder builder = new StringBuilder();
int url;
do {
url = number.mod(new BigInteger("36")).intValue();
number = number.divide(new BigInteger("36"));
builder.append(alphabet.charAt(url));
} while (number.compareTo(BigInteger.ZERO) > 0);
return builder.toString();
}
|
590532_4
|
public static String encode(String raw) {
String[] parts = parseId(raw);
return shorten(toBigInteger(parts[0])) + "-" +
shorten(toBigInteger(parts[1], parts[2])) + "-" +
shorten(new BigInteger(parts[3]));
}
|
590532_5
|
@Override
public Contact getContact(Endpoint addr, Endpoint contact) {
HColumn<String, Object> result = queryResult(addr, contact);
if (result == null) {
return null;
}
return (Contact) result.getValue();
}
|
590532_6
|
@Override
public boolean isExisting(Endpoint addr, Contact contact) {
CountQuery<String, Object> query = HFactory.createCountQuery(_keyspace, STRING_SERIALIZER, OBJECT_SERIALIZER);
query.setColumnFamily(DEFAULT_COLUMN_FAMILY_NAME);
query.setKey(getCleanUri(addr));
query.setRange(contact.getEndpoint().getURI().toString(), contact.getEndpoint().getURI().toString(), 1);
QueryResult<Integer> execute = query.execute();
return execute.get().intValue() > 0;
return queryResult(addr, contact.getEndpoint()) != null;
}
|
591784_0
|
public CollectResult collectDependencies( RepositorySystemSession session, CollectRequest request )
throws DependencyCollectionException
{
session = optimizeSession( session );
RequestTrace trace = DefaultRequestTrace.newChild( request.getTrace(), request );
CollectResult result = new CollectResult( request );
DependencySelector depSelector = session.getDependencySelector();
DependencyManager depManager = session.getDependencyManager();
DependencyTraverser depTraverser = session.getDependencyTraverser();
Dependency root = request.getRoot();
List<RemoteRepository> repositories = request.getRepositories();
List<Dependency> dependencies = request.getDependencies();
List<Dependency> managedDependencies = request.getManagedDependencies();
GraphEdge edge = null;
if ( root != null )
{
VersionRangeResult rangeResult;
try
{
VersionRangeRequest rangeRequest =
new VersionRangeRequest( root.getArtifact(), request.getRepositories(), request.getRequestContext() );
rangeRequest.setTrace( trace );
rangeResult = versionRangeResolver.resolveVersionRange( session, rangeRequest );
if ( rangeResult.getVersions().isEmpty() )
{
throw new VersionRangeResolutionException( rangeResult, "No versions available for "
+ root.getArtifact() + " within specified range" );
}
}
catch ( VersionRangeResolutionException e )
{
result.addException( e );
throw new DependencyCollectionException( result );
}
Version version = rangeResult.getVersions().get( rangeResult.getVersions().size() - 1 );
root = root.setArtifact( root.getArtifact().setVersion( version.toString() ) );
ArtifactDescriptorResult descriptorResult;
try
{
ArtifactDescriptorRequest descriptorRequest = new ArtifactDescriptorRequest();
descriptorRequest.setArtifact( root.getArtifact() );
descriptorRequest.setRepositories( request.getRepositories() );
descriptorRequest.setRequestContext( request.getRequestContext() );
descriptorRequest.setTrace( trace );
if ( isLackingDescriptor( root.getArtifact() ) )
{
descriptorResult = new ArtifactDescriptorResult( descriptorRequest );
}
else
{
descriptorResult = descriptorReader.readArtifactDescriptor( session, descriptorRequest );
}
}
catch ( ArtifactDescriptorException e )
{
result.addException( e );
throw new DependencyCollectionException( result );
}
root = root.setArtifact( descriptorResult.getArtifact() );
repositories =
remoteRepositoryManager.aggregateRepositories( session, repositories,
descriptorResult.getRepositories(), true );
dependencies = mergeDeps( dependencies, descriptorResult.getDependencies() );
managedDependencies = mergeDeps( managedDependencies, descriptorResult.getManagedDependencies() );
GraphNode node = new GraphNode();
node.setAliases( descriptorResult.getAliases() );
node.setRepositories( request.getRepositories() );
edge = new GraphEdge( node );
edge.setDependency( root );
edge.setRequestContext( request.getRequestContext() );
edge.setRelocations( descriptorResult.getRelocations() );
edge.setVersionConstraint( rangeResult.getVersionConstraint() );
edge.setVersion( version );
}
else
{
edge = new GraphEdge( new GraphNode() );
}
result.setRoot( edge );
boolean traverse = ( root == null ) || depTraverser.traverseDependency( root );
if ( traverse && !dependencies.isEmpty() )
{
DataPool pool = new DataPool( session );
EdgeStack edges = new EdgeStack();
edges.push( edge );
DefaultDependencyCollectionContext context =
new DefaultDependencyCollectionContext( session, root, managedDependencies );
Args args = new Args( result, session, trace, pool, edges, context );
process( args, dependencies, repositories, depSelector.deriveChildSelector( context ),
depManager.deriveChildManager( context ), depTraverser.deriveChildTraverser( context ) );
}
DependencyGraphTransformer transformer = session.getDependencyGraphTransformer();
try
{
DefaultDependencyGraphTransformationContext context =
new DefaultDependencyGraphTransformationContext( session );
result.setRoot( transformer.transformGraph( edge, context ) );
}
catch ( RepositoryException e )
{
result.addException( e );
}
if ( !result.getExceptions().isEmpty() )
{
throw new DependencyCollectionException( result );
}
return result;
}
|
591784_1
|
public CollectResult collectDependencies( RepositorySystemSession session, CollectRequest request )
throws DependencyCollectionException
{
session = optimizeSession( session );
RequestTrace trace = DefaultRequestTrace.newChild( request.getTrace(), request );
CollectResult result = new CollectResult( request );
DependencySelector depSelector = session.getDependencySelector();
DependencyManager depManager = session.getDependencyManager();
DependencyTraverser depTraverser = session.getDependencyTraverser();
Dependency root = request.getRoot();
List<RemoteRepository> repositories = request.getRepositories();
List<Dependency> dependencies = request.getDependencies();
List<Dependency> managedDependencies = request.getManagedDependencies();
GraphEdge edge = null;
if ( root != null )
{
VersionRangeResult rangeResult;
try
{
VersionRangeRequest rangeRequest =
new VersionRangeRequest( root.getArtifact(), request.getRepositories(), request.getRequestContext() );
rangeRequest.setTrace( trace );
rangeResult = versionRangeResolver.resolveVersionRange( session, rangeRequest );
if ( rangeResult.getVersions().isEmpty() )
{
throw new VersionRangeResolutionException( rangeResult, "No versions available for "
+ root.getArtifact() + " within specified range" );
}
}
catch ( VersionRangeResolutionException e )
{
result.addException( e );
throw new DependencyCollectionException( result );
}
Version version = rangeResult.getVersions().get( rangeResult.getVersions().size() - 1 );
root = root.setArtifact( root.getArtifact().setVersion( version.toString() ) );
ArtifactDescriptorResult descriptorResult;
try
{
ArtifactDescriptorRequest descriptorRequest = new ArtifactDescriptorRequest();
descriptorRequest.setArtifact( root.getArtifact() );
descriptorRequest.setRepositories( request.getRepositories() );
descriptorRequest.setRequestContext( request.getRequestContext() );
descriptorRequest.setTrace( trace );
if ( isLackingDescriptor( root.getArtifact() ) )
{
descriptorResult = new ArtifactDescriptorResult( descriptorRequest );
}
else
{
descriptorResult = descriptorReader.readArtifactDescriptor( session, descriptorRequest );
}
}
catch ( ArtifactDescriptorException e )
{
result.addException( e );
throw new DependencyCollectionException( result );
}
root = root.setArtifact( descriptorResult.getArtifact() );
repositories =
remoteRepositoryManager.aggregateRepositories( session, repositories,
descriptorResult.getRepositories(), true );
dependencies = mergeDeps( dependencies, descriptorResult.getDependencies() );
managedDependencies = mergeDeps( managedDependencies, descriptorResult.getManagedDependencies() );
GraphNode node = new GraphNode();
node.setAliases( descriptorResult.getAliases() );
node.setRepositories( request.getRepositories() );
edge = new GraphEdge( node );
edge.setDependency( root );
edge.setRequestContext( request.getRequestContext() );
edge.setRelocations( descriptorResult.getRelocations() );
edge.setVersionConstraint( rangeResult.getVersionConstraint() );
edge.setVersion( version );
}
else
{
edge = new GraphEdge( new GraphNode() );
}
result.setRoot( edge );
boolean traverse = ( root == null ) || depTraverser.traverseDependency( root );
if ( traverse && !dependencies.isEmpty() )
{
DataPool pool = new DataPool( session );
EdgeStack edges = new EdgeStack();
edges.push( edge );
DefaultDependencyCollectionContext context =
new DefaultDependencyCollectionContext( session, root, managedDependencies );
Args args = new Args( result, session, trace, pool, edges, context );
process( args, dependencies, repositories, depSelector.deriveChildSelector( context ),
depManager.deriveChildManager( context ), depTraverser.deriveChildTraverser( context ) );
}
DependencyGraphTransformer transformer = session.getDependencyGraphTransformer();
try
{
DefaultDependencyGraphTransformationContext context =
new DefaultDependencyGraphTransformationContext( session );
result.setRoot( transformer.transformGraph( edge, context ) );
}
catch ( RepositoryException e )
{
result.addException( e );
}
if ( !result.getExceptions().isEmpty() )
{
throw new DependencyCollectionException( result );
}
return result;
}
|
591784_2
|
public CollectResult collectDependencies( RepositorySystemSession session, CollectRequest request )
throws DependencyCollectionException
{
session = optimizeSession( session );
RequestTrace trace = DefaultRequestTrace.newChild( request.getTrace(), request );
CollectResult result = new CollectResult( request );
DependencySelector depSelector = session.getDependencySelector();
DependencyManager depManager = session.getDependencyManager();
DependencyTraverser depTraverser = session.getDependencyTraverser();
Dependency root = request.getRoot();
List<RemoteRepository> repositories = request.getRepositories();
List<Dependency> dependencies = request.getDependencies();
List<Dependency> managedDependencies = request.getManagedDependencies();
GraphEdge edge = null;
if ( root != null )
{
VersionRangeResult rangeResult;
try
{
VersionRangeRequest rangeRequest =
new VersionRangeRequest( root.getArtifact(), request.getRepositories(), request.getRequestContext() );
rangeRequest.setTrace( trace );
rangeResult = versionRangeResolver.resolveVersionRange( session, rangeRequest );
if ( rangeResult.getVersions().isEmpty() )
{
throw new VersionRangeResolutionException( rangeResult, "No versions available for "
+ root.getArtifact() + " within specified range" );
}
}
catch ( VersionRangeResolutionException e )
{
result.addException( e );
throw new DependencyCollectionException( result );
}
Version version = rangeResult.getVersions().get( rangeResult.getVersions().size() - 1 );
root = root.setArtifact( root.getArtifact().setVersion( version.toString() ) );
ArtifactDescriptorResult descriptorResult;
try
{
ArtifactDescriptorRequest descriptorRequest = new ArtifactDescriptorRequest();
descriptorRequest.setArtifact( root.getArtifact() );
descriptorRequest.setRepositories( request.getRepositories() );
descriptorRequest.setRequestContext( request.getRequestContext() );
descriptorRequest.setTrace( trace );
if ( isLackingDescriptor( root.getArtifact() ) )
{
descriptorResult = new ArtifactDescriptorResult( descriptorRequest );
}
else
{
descriptorResult = descriptorReader.readArtifactDescriptor( session, descriptorRequest );
}
}
catch ( ArtifactDescriptorException e )
{
result.addException( e );
throw new DependencyCollectionException( result );
}
root = root.setArtifact( descriptorResult.getArtifact() );
repositories =
remoteRepositoryManager.aggregateRepositories( session, repositories,
descriptorResult.getRepositories(), true );
dependencies = mergeDeps( dependencies, descriptorResult.getDependencies() );
managedDependencies = mergeDeps( managedDependencies, descriptorResult.getManagedDependencies() );
GraphNode node = new GraphNode();
node.setAliases( descriptorResult.getAliases() );
node.setRepositories( request.getRepositories() );
edge = new GraphEdge( node );
edge.setDependency( root );
edge.setRequestContext( request.getRequestContext() );
edge.setRelocations( descriptorResult.getRelocations() );
edge.setVersionConstraint( rangeResult.getVersionConstraint() );
edge.setVersion( version );
}
else
{
edge = new GraphEdge( new GraphNode() );
}
result.setRoot( edge );
boolean traverse = ( root == null ) || depTraverser.traverseDependency( root );
if ( traverse && !dependencies.isEmpty() )
{
DataPool pool = new DataPool( session );
EdgeStack edges = new EdgeStack();
edges.push( edge );
DefaultDependencyCollectionContext context =
new DefaultDependencyCollectionContext( session, root, managedDependencies );
Args args = new Args( result, session, trace, pool, edges, context );
process( args, dependencies, repositories, depSelector.deriveChildSelector( context ),
depManager.deriveChildManager( context ), depTraverser.deriveChildTraverser( context ) );
}
DependencyGraphTransformer transformer = session.getDependencyGraphTransformer();
try
{
DefaultDependencyGraphTransformationContext context =
new DefaultDependencyGraphTransformationContext( session );
result.setRoot( transformer.transformGraph( edge, context ) );
}
catch ( RepositoryException e )
{
result.addException( e );
}
if ( !result.getExceptions().isEmpty() )
{
throw new DependencyCollectionException( result );
}
return result;
}
|
591784_3
|
public CollectResult collectDependencies( RepositorySystemSession session, CollectRequest request )
throws DependencyCollectionException
{
session = optimizeSession( session );
RequestTrace trace = DefaultRequestTrace.newChild( request.getTrace(), request );
CollectResult result = new CollectResult( request );
DependencySelector depSelector = session.getDependencySelector();
DependencyManager depManager = session.getDependencyManager();
DependencyTraverser depTraverser = session.getDependencyTraverser();
Dependency root = request.getRoot();
List<RemoteRepository> repositories = request.getRepositories();
List<Dependency> dependencies = request.getDependencies();
List<Dependency> managedDependencies = request.getManagedDependencies();
GraphEdge edge = null;
if ( root != null )
{
VersionRangeResult rangeResult;
try
{
VersionRangeRequest rangeRequest =
new VersionRangeRequest( root.getArtifact(), request.getRepositories(), request.getRequestContext() );
rangeRequest.setTrace( trace );
rangeResult = versionRangeResolver.resolveVersionRange( session, rangeRequest );
if ( rangeResult.getVersions().isEmpty() )
{
throw new VersionRangeResolutionException( rangeResult, "No versions available for "
+ root.getArtifact() + " within specified range" );
}
}
catch ( VersionRangeResolutionException e )
{
result.addException( e );
throw new DependencyCollectionException( result );
}
Version version = rangeResult.getVersions().get( rangeResult.getVersions().size() - 1 );
root = root.setArtifact( root.getArtifact().setVersion( version.toString() ) );
ArtifactDescriptorResult descriptorResult;
try
{
ArtifactDescriptorRequest descriptorRequest = new ArtifactDescriptorRequest();
descriptorRequest.setArtifact( root.getArtifact() );
descriptorRequest.setRepositories( request.getRepositories() );
descriptorRequest.setRequestContext( request.getRequestContext() );
descriptorRequest.setTrace( trace );
if ( isLackingDescriptor( root.getArtifact() ) )
{
descriptorResult = new ArtifactDescriptorResult( descriptorRequest );
}
else
{
descriptorResult = descriptorReader.readArtifactDescriptor( session, descriptorRequest );
}
}
catch ( ArtifactDescriptorException e )
{
result.addException( e );
throw new DependencyCollectionException( result );
}
root = root.setArtifact( descriptorResult.getArtifact() );
repositories =
remoteRepositoryManager.aggregateRepositories( session, repositories,
descriptorResult.getRepositories(), true );
dependencies = mergeDeps( dependencies, descriptorResult.getDependencies() );
managedDependencies = mergeDeps( managedDependencies, descriptorResult.getManagedDependencies() );
GraphNode node = new GraphNode();
node.setAliases( descriptorResult.getAliases() );
node.setRepositories( request.getRepositories() );
edge = new GraphEdge( node );
edge.setDependency( root );
edge.setRequestContext( request.getRequestContext() );
edge.setRelocations( descriptorResult.getRelocations() );
edge.setVersionConstraint( rangeResult.getVersionConstraint() );
edge.setVersion( version );
}
else
{
edge = new GraphEdge( new GraphNode() );
}
result.setRoot( edge );
boolean traverse = ( root == null ) || depTraverser.traverseDependency( root );
if ( traverse && !dependencies.isEmpty() )
{
DataPool pool = new DataPool( session );
EdgeStack edges = new EdgeStack();
edges.push( edge );
DefaultDependencyCollectionContext context =
new DefaultDependencyCollectionContext( session, root, managedDependencies );
Args args = new Args( result, session, trace, pool, edges, context );
process( args, dependencies, repositories, depSelector.deriveChildSelector( context ),
depManager.deriveChildManager( context ), depTraverser.deriveChildTraverser( context ) );
}
DependencyGraphTransformer transformer = session.getDependencyGraphTransformer();
try
{
DefaultDependencyGraphTransformationContext context =
new DefaultDependencyGraphTransformationContext( session );
result.setRoot( transformer.transformGraph( edge, context ) );
}
catch ( RepositoryException e )
{
result.addException( e );
}
if ( !result.getExceptions().isEmpty() )
{
throw new DependencyCollectionException( result );
}
return result;
}
|
591784_4
|
public CollectResult collectDependencies( RepositorySystemSession session, CollectRequest request )
throws DependencyCollectionException
{
session = optimizeSession( session );
RequestTrace trace = DefaultRequestTrace.newChild( request.getTrace(), request );
CollectResult result = new CollectResult( request );
DependencySelector depSelector = session.getDependencySelector();
DependencyManager depManager = session.getDependencyManager();
DependencyTraverser depTraverser = session.getDependencyTraverser();
Dependency root = request.getRoot();
List<RemoteRepository> repositories = request.getRepositories();
List<Dependency> dependencies = request.getDependencies();
List<Dependency> managedDependencies = request.getManagedDependencies();
GraphEdge edge = null;
if ( root != null )
{
VersionRangeResult rangeResult;
try
{
VersionRangeRequest rangeRequest =
new VersionRangeRequest( root.getArtifact(), request.getRepositories(), request.getRequestContext() );
rangeRequest.setTrace( trace );
rangeResult = versionRangeResolver.resolveVersionRange( session, rangeRequest );
if ( rangeResult.getVersions().isEmpty() )
{
throw new VersionRangeResolutionException( rangeResult, "No versions available for "
+ root.getArtifact() + " within specified range" );
}
}
catch ( VersionRangeResolutionException e )
{
result.addException( e );
throw new DependencyCollectionException( result );
}
Version version = rangeResult.getVersions().get( rangeResult.getVersions().size() - 1 );
root = root.setArtifact( root.getArtifact().setVersion( version.toString() ) );
ArtifactDescriptorResult descriptorResult;
try
{
ArtifactDescriptorRequest descriptorRequest = new ArtifactDescriptorRequest();
descriptorRequest.setArtifact( root.getArtifact() );
descriptorRequest.setRepositories( request.getRepositories() );
descriptorRequest.setRequestContext( request.getRequestContext() );
descriptorRequest.setTrace( trace );
if ( isLackingDescriptor( root.getArtifact() ) )
{
descriptorResult = new ArtifactDescriptorResult( descriptorRequest );
}
else
{
descriptorResult = descriptorReader.readArtifactDescriptor( session, descriptorRequest );
}
}
catch ( ArtifactDescriptorException e )
{
result.addException( e );
throw new DependencyCollectionException( result );
}
root = root.setArtifact( descriptorResult.getArtifact() );
repositories =
remoteRepositoryManager.aggregateRepositories( session, repositories,
descriptorResult.getRepositories(), true );
dependencies = mergeDeps( dependencies, descriptorResult.getDependencies() );
managedDependencies = mergeDeps( managedDependencies, descriptorResult.getManagedDependencies() );
GraphNode node = new GraphNode();
node.setAliases( descriptorResult.getAliases() );
node.setRepositories( request.getRepositories() );
edge = new GraphEdge( node );
edge.setDependency( root );
edge.setRequestContext( request.getRequestContext() );
edge.setRelocations( descriptorResult.getRelocations() );
edge.setVersionConstraint( rangeResult.getVersionConstraint() );
edge.setVersion( version );
}
else
{
edge = new GraphEdge( new GraphNode() );
}
result.setRoot( edge );
boolean traverse = ( root == null ) || depTraverser.traverseDependency( root );
if ( traverse && !dependencies.isEmpty() )
{
DataPool pool = new DataPool( session );
EdgeStack edges = new EdgeStack();
edges.push( edge );
DefaultDependencyCollectionContext context =
new DefaultDependencyCollectionContext( session, root, managedDependencies );
Args args = new Args( result, session, trace, pool, edges, context );
process( args, dependencies, repositories, depSelector.deriveChildSelector( context ),
depManager.deriveChildManager( context ), depTraverser.deriveChildTraverser( context ) );
}
DependencyGraphTransformer transformer = session.getDependencyGraphTransformer();
try
{
DefaultDependencyGraphTransformationContext context =
new DefaultDependencyGraphTransformationContext( session );
result.setRoot( transformer.transformGraph( edge, context ) );
}
catch ( RepositoryException e )
{
result.addException( e );
}
if ( !result.getExceptions().isEmpty() )
{
throw new DependencyCollectionException( result );
}
return result;
}
|
591784_5
|
public CollectResult collectDependencies( RepositorySystemSession session, CollectRequest request )
throws DependencyCollectionException
{
session = optimizeSession( session );
RequestTrace trace = DefaultRequestTrace.newChild( request.getTrace(), request );
CollectResult result = new CollectResult( request );
DependencySelector depSelector = session.getDependencySelector();
DependencyManager depManager = session.getDependencyManager();
DependencyTraverser depTraverser = session.getDependencyTraverser();
Dependency root = request.getRoot();
List<RemoteRepository> repositories = request.getRepositories();
List<Dependency> dependencies = request.getDependencies();
List<Dependency> managedDependencies = request.getManagedDependencies();
GraphEdge edge = null;
if ( root != null )
{
VersionRangeResult rangeResult;
try
{
VersionRangeRequest rangeRequest =
new VersionRangeRequest( root.getArtifact(), request.getRepositories(), request.getRequestContext() );
rangeRequest.setTrace( trace );
rangeResult = versionRangeResolver.resolveVersionRange( session, rangeRequest );
if ( rangeResult.getVersions().isEmpty() )
{
throw new VersionRangeResolutionException( rangeResult, "No versions available for "
+ root.getArtifact() + " within specified range" );
}
}
catch ( VersionRangeResolutionException e )
{
result.addException( e );
throw new DependencyCollectionException( result );
}
Version version = rangeResult.getVersions().get( rangeResult.getVersions().size() - 1 );
root = root.setArtifact( root.getArtifact().setVersion( version.toString() ) );
ArtifactDescriptorResult descriptorResult;
try
{
ArtifactDescriptorRequest descriptorRequest = new ArtifactDescriptorRequest();
descriptorRequest.setArtifact( root.getArtifact() );
descriptorRequest.setRepositories( request.getRepositories() );
descriptorRequest.setRequestContext( request.getRequestContext() );
descriptorRequest.setTrace( trace );
if ( isLackingDescriptor( root.getArtifact() ) )
{
descriptorResult = new ArtifactDescriptorResult( descriptorRequest );
}
else
{
descriptorResult = descriptorReader.readArtifactDescriptor( session, descriptorRequest );
}
}
catch ( ArtifactDescriptorException e )
{
result.addException( e );
throw new DependencyCollectionException( result );
}
root = root.setArtifact( descriptorResult.getArtifact() );
repositories =
remoteRepositoryManager.aggregateRepositories( session, repositories,
descriptorResult.getRepositories(), true );
dependencies = mergeDeps( dependencies, descriptorResult.getDependencies() );
managedDependencies = mergeDeps( managedDependencies, descriptorResult.getManagedDependencies() );
GraphNode node = new GraphNode();
node.setAliases( descriptorResult.getAliases() );
node.setRepositories( request.getRepositories() );
edge = new GraphEdge( node );
edge.setDependency( root );
edge.setRequestContext( request.getRequestContext() );
edge.setRelocations( descriptorResult.getRelocations() );
edge.setVersionConstraint( rangeResult.getVersionConstraint() );
edge.setVersion( version );
}
else
{
edge = new GraphEdge( new GraphNode() );
}
result.setRoot( edge );
boolean traverse = ( root == null ) || depTraverser.traverseDependency( root );
if ( traverse && !dependencies.isEmpty() )
{
DataPool pool = new DataPool( session );
EdgeStack edges = new EdgeStack();
edges.push( edge );
DefaultDependencyCollectionContext context =
new DefaultDependencyCollectionContext( session, root, managedDependencies );
Args args = new Args( result, session, trace, pool, edges, context );
process( args, dependencies, repositories, depSelector.deriveChildSelector( context ),
depManager.deriveChildManager( context ), depTraverser.deriveChildTraverser( context ) );
}
DependencyGraphTransformer transformer = session.getDependencyGraphTransformer();
try
{
DefaultDependencyGraphTransformationContext context =
new DefaultDependencyGraphTransformationContext( session );
result.setRoot( transformer.transformGraph( edge, context ) );
}
catch ( RepositoryException e )
{
result.addException( e );
}
if ( !result.getExceptions().isEmpty() )
{
throw new DependencyCollectionException( result );
}
return result;
}
|
591784_6
|
public CollectResult collectDependencies( RepositorySystemSession session, CollectRequest request )
throws DependencyCollectionException
{
session = optimizeSession( session );
RequestTrace trace = DefaultRequestTrace.newChild( request.getTrace(), request );
CollectResult result = new CollectResult( request );
DependencySelector depSelector = session.getDependencySelector();
DependencyManager depManager = session.getDependencyManager();
DependencyTraverser depTraverser = session.getDependencyTraverser();
Dependency root = request.getRoot();
List<RemoteRepository> repositories = request.getRepositories();
List<Dependency> dependencies = request.getDependencies();
List<Dependency> managedDependencies = request.getManagedDependencies();
GraphEdge edge = null;
if ( root != null )
{
VersionRangeResult rangeResult;
try
{
VersionRangeRequest rangeRequest =
new VersionRangeRequest( root.getArtifact(), request.getRepositories(), request.getRequestContext() );
rangeRequest.setTrace( trace );
rangeResult = versionRangeResolver.resolveVersionRange( session, rangeRequest );
if ( rangeResult.getVersions().isEmpty() )
{
throw new VersionRangeResolutionException( rangeResult, "No versions available for "
+ root.getArtifact() + " within specified range" );
}
}
catch ( VersionRangeResolutionException e )
{
result.addException( e );
throw new DependencyCollectionException( result );
}
Version version = rangeResult.getVersions().get( rangeResult.getVersions().size() - 1 );
root = root.setArtifact( root.getArtifact().setVersion( version.toString() ) );
ArtifactDescriptorResult descriptorResult;
try
{
ArtifactDescriptorRequest descriptorRequest = new ArtifactDescriptorRequest();
descriptorRequest.setArtifact( root.getArtifact() );
descriptorRequest.setRepositories( request.getRepositories() );
descriptorRequest.setRequestContext( request.getRequestContext() );
descriptorRequest.setTrace( trace );
if ( isLackingDescriptor( root.getArtifact() ) )
{
descriptorResult = new ArtifactDescriptorResult( descriptorRequest );
}
else
{
descriptorResult = descriptorReader.readArtifactDescriptor( session, descriptorRequest );
}
}
catch ( ArtifactDescriptorException e )
{
result.addException( e );
throw new DependencyCollectionException( result );
}
root = root.setArtifact( descriptorResult.getArtifact() );
repositories =
remoteRepositoryManager.aggregateRepositories( session, repositories,
descriptorResult.getRepositories(), true );
dependencies = mergeDeps( dependencies, descriptorResult.getDependencies() );
managedDependencies = mergeDeps( managedDependencies, descriptorResult.getManagedDependencies() );
GraphNode node = new GraphNode();
node.setAliases( descriptorResult.getAliases() );
node.setRepositories( request.getRepositories() );
edge = new GraphEdge( node );
edge.setDependency( root );
edge.setRequestContext( request.getRequestContext() );
edge.setRelocations( descriptorResult.getRelocations() );
edge.setVersionConstraint( rangeResult.getVersionConstraint() );
edge.setVersion( version );
}
else
{
edge = new GraphEdge( new GraphNode() );
}
result.setRoot( edge );
boolean traverse = ( root == null ) || depTraverser.traverseDependency( root );
if ( traverse && !dependencies.isEmpty() )
{
DataPool pool = new DataPool( session );
EdgeStack edges = new EdgeStack();
edges.push( edge );
DefaultDependencyCollectionContext context =
new DefaultDependencyCollectionContext( session, root, managedDependencies );
Args args = new Args( result, session, trace, pool, edges, context );
process( args, dependencies, repositories, depSelector.deriveChildSelector( context ),
depManager.deriveChildManager( context ), depTraverser.deriveChildTraverser( context ) );
}
DependencyGraphTransformer transformer = session.getDependencyGraphTransformer();
try
{
DefaultDependencyGraphTransformationContext context =
new DefaultDependencyGraphTransformationContext( session );
result.setRoot( transformer.transformGraph( edge, context ) );
}
catch ( RepositoryException e )
{
result.addException( e );
}
if ( !result.getExceptions().isEmpty() )
{
throw new DependencyCollectionException( result );
}
return result;
}
|
591784_7
|
public CollectResult collectDependencies( RepositorySystemSession session, CollectRequest request )
throws DependencyCollectionException
{
session = optimizeSession( session );
RequestTrace trace = DefaultRequestTrace.newChild( request.getTrace(), request );
CollectResult result = new CollectResult( request );
DependencySelector depSelector = session.getDependencySelector();
DependencyManager depManager = session.getDependencyManager();
DependencyTraverser depTraverser = session.getDependencyTraverser();
Dependency root = request.getRoot();
List<RemoteRepository> repositories = request.getRepositories();
List<Dependency> dependencies = request.getDependencies();
List<Dependency> managedDependencies = request.getManagedDependencies();
GraphEdge edge = null;
if ( root != null )
{
VersionRangeResult rangeResult;
try
{
VersionRangeRequest rangeRequest =
new VersionRangeRequest( root.getArtifact(), request.getRepositories(), request.getRequestContext() );
rangeRequest.setTrace( trace );
rangeResult = versionRangeResolver.resolveVersionRange( session, rangeRequest );
if ( rangeResult.getVersions().isEmpty() )
{
throw new VersionRangeResolutionException( rangeResult, "No versions available for "
+ root.getArtifact() + " within specified range" );
}
}
catch ( VersionRangeResolutionException e )
{
result.addException( e );
throw new DependencyCollectionException( result );
}
Version version = rangeResult.getVersions().get( rangeResult.getVersions().size() - 1 );
root = root.setArtifact( root.getArtifact().setVersion( version.toString() ) );
ArtifactDescriptorResult descriptorResult;
try
{
ArtifactDescriptorRequest descriptorRequest = new ArtifactDescriptorRequest();
descriptorRequest.setArtifact( root.getArtifact() );
descriptorRequest.setRepositories( request.getRepositories() );
descriptorRequest.setRequestContext( request.getRequestContext() );
descriptorRequest.setTrace( trace );
if ( isLackingDescriptor( root.getArtifact() ) )
{
descriptorResult = new ArtifactDescriptorResult( descriptorRequest );
}
else
{
descriptorResult = descriptorReader.readArtifactDescriptor( session, descriptorRequest );
}
}
catch ( ArtifactDescriptorException e )
{
result.addException( e );
throw new DependencyCollectionException( result );
}
root = root.setArtifact( descriptorResult.getArtifact() );
repositories =
remoteRepositoryManager.aggregateRepositories( session, repositories,
descriptorResult.getRepositories(), true );
dependencies = mergeDeps( dependencies, descriptorResult.getDependencies() );
managedDependencies = mergeDeps( managedDependencies, descriptorResult.getManagedDependencies() );
GraphNode node = new GraphNode();
node.setAliases( descriptorResult.getAliases() );
node.setRepositories( request.getRepositories() );
edge = new GraphEdge( node );
edge.setDependency( root );
edge.setRequestContext( request.getRequestContext() );
edge.setRelocations( descriptorResult.getRelocations() );
edge.setVersionConstraint( rangeResult.getVersionConstraint() );
edge.setVersion( version );
}
else
{
edge = new GraphEdge( new GraphNode() );
}
result.setRoot( edge );
boolean traverse = ( root == null ) || depTraverser.traverseDependency( root );
if ( traverse && !dependencies.isEmpty() )
{
DataPool pool = new DataPool( session );
EdgeStack edges = new EdgeStack();
edges.push( edge );
DefaultDependencyCollectionContext context =
new DefaultDependencyCollectionContext( session, root, managedDependencies );
Args args = new Args( result, session, trace, pool, edges, context );
process( args, dependencies, repositories, depSelector.deriveChildSelector( context ),
depManager.deriveChildManager( context ), depTraverser.deriveChildTraverser( context ) );
}
DependencyGraphTransformer transformer = session.getDependencyGraphTransformer();
try
{
DefaultDependencyGraphTransformationContext context =
new DefaultDependencyGraphTransformationContext( session );
result.setRoot( transformer.transformGraph( edge, context ) );
}
catch ( RepositoryException e )
{
result.addException( e );
}
if ( !result.getExceptions().isEmpty() )
{
throw new DependencyCollectionException( result );
}
return result;
}
|
591784_8
|
public List<MetadataResult> resolveMetadata( RepositorySystemSession session,
Collection<? extends MetadataRequest> requests )
{
SyncContext syncContext = syncContextFactory.newInstance( session, false );
try
{
Collection<Metadata> metadata = new ArrayList<Metadata>( requests.size() );
for ( MetadataRequest request : requests )
{
metadata.add( request.getMetadata() );
}
syncContext.acquire( null, metadata );
return resolve( session, requests );
}
finally
{
syncContext.release();
}
}
|
591784_9
|
private List<MetadataResult> resolve( RepositorySystemSession session,
Collection<? extends MetadataRequest> requests )
{
List<MetadataResult> results = new ArrayList<MetadataResult>( requests.size() );
List<ResolveTask> tasks = new ArrayList<ResolveTask>( requests.size() );
Map<File, Long> localLastUpdates = new HashMap<File, Long>();
for ( MetadataRequest request : requests )
{
RequestTrace trace = DefaultRequestTrace.newChild( request.getTrace(), request );
MetadataResult result = new MetadataResult( request );
results.add( result );
Metadata metadata = request.getMetadata();
RemoteRepository repository = request.getRepository();
if ( repository == null )
{
LocalRepository localRepo = session.getLocalRepositoryManager().getRepository();
metadataResolving( session, trace, metadata, localRepo );
File localFile = getLocalFile( session, metadata );
if ( localFile != null )
{
metadata = metadata.setFile( localFile );
result.setMetadata( metadata );
}
else
{
result.setException( new MetadataNotFoundException( metadata, localRepo ) );
}
metadataResolved( session, trace, metadata, localRepo, result.getException() );
continue;
}
List<RemoteRepository> repositories = getEnabledSourceRepositories( repository, metadata.getNature() );
if ( repositories.isEmpty() )
{
continue;
}
metadataResolving( session, trace, metadata, repository );
LocalRepositoryManager lrm = session.getLocalRepositoryManager();
LocalMetadataRequest localRequest =
new LocalMetadataRequest( metadata, repository, request.getRequestContext() );
LocalMetadataResult lrmResult = lrm.find( session, localRequest );
File metadataFile = lrmResult.getFile();
if ( session.isOffline() )
{
if ( metadataFile != null )
{
metadata = metadata.setFile( metadataFile );
result.setMetadata( metadata );
}
else
{
String msg =
"The repository system is offline but the metadata " + metadata + " from " + repository
+ " is not available in the local repository.";
result.setException( new MetadataNotFoundException( metadata, repository, msg ) );
}
metadataResolved( session, trace, metadata, repository, result.getException() );
continue;
}
Long localLastUpdate = null;
if ( request.isFavorLocalRepository() )
{
File localFile = getLocalFile( session, metadata );
localLastUpdate = localLastUpdates.get( localFile );
if ( localLastUpdate == null )
{
localLastUpdate = Long.valueOf( localFile != null ? localFile.lastModified() : 0 );
localLastUpdates.put( localFile, localLastUpdate );
}
}
List<UpdateCheck<Metadata, MetadataTransferException>> checks =
new ArrayList<UpdateCheck<Metadata, MetadataTransferException>>();
Exception exception = null;
for ( RemoteRepository repo : repositories )
{
UpdateCheck<Metadata, MetadataTransferException> check =
new UpdateCheck<Metadata, MetadataTransferException>();
check.setLocalLastUpdated( ( localLastUpdate != null ) ? localLastUpdate.longValue() : 0 );
check.setItem( metadata );
// use 'main' installation file for the check (-> use requested repository)
File checkFile =
new File(
session.getLocalRepository().getBasedir(),
session.getLocalRepositoryManager().getPathForRemoteMetadata( metadata, repository,
request.getRequestContext() ) );
check.setFile( checkFile );
check.setRepository( repository );
check.setAuthoritativeRepository( repo );
check.setPolicy( getPolicy( session, repo, metadata.getNature() ).getUpdatePolicy() );
if ( lrmResult.isStale() )
{
checks.add( check );
}
else
{
updateCheckManager.checkMetadata( session, check );
if ( check.isRequired() )
{
checks.add( check );
}
else if ( exception == null )
{
exception = check.getException();
}
}
}
if ( !checks.isEmpty() )
{
RepositoryPolicy policy = getPolicy( session, repository, metadata.getNature() );
// install path may be different from lookup path
File installFile =
new File(
session.getLocalRepository().getBasedir(),
session.getLocalRepositoryManager().getPathForRemoteMetadata( metadata,
request.getRepository(),
request.getRequestContext() ) );
ResolveTask task =
new ResolveTask( session, trace, result, installFile, checks, policy.getChecksumPolicy() );
tasks.add( task );
}
else
{
result.setException( exception );
if ( metadataFile != null )
{
metadata = metadata.setFile( metadataFile );
result.setMetadata( metadata );
}
metadataResolved( session, trace, metadata, repository, result.getException() );
}
}
if ( !tasks.isEmpty() )
{
int threads = ConfigUtils.getInteger( session, 4, "aether.metadataResolver.threads" );
Executor executor = getExecutor( Math.min( tasks.size(), threads ) );
try
{
RunnableErrorForwarder errorForwarder = new RunnableErrorForwarder();
for ( ResolveTask task : tasks )
{
executor.execute( errorForwarder.wrap( task ) );
}
errorForwarder.await();
for ( ResolveTask task : tasks )
{
task.result.setException( task.exception );
}
}
finally
{
shutdown( executor );
}
for ( ResolveTask task : tasks )
{
Metadata metadata = task.request.getMetadata();
// re-lookup metadata for resolve
LocalMetadataRequest localRequest =
new LocalMetadataRequest( metadata, task.request.getRepository(), task.request.getRequestContext() );
File metadataFile = session.getLocalRepositoryManager().find( session, localRequest ).getFile();
if ( metadataFile != null )
{
metadata = metadata.setFile( metadataFile );
task.result.setMetadata( metadata );
}
if ( task.result.getException() == null )
{
task.result.setUpdated( true );
}
metadataResolved( session, task.trace, metadata, task.request.getRepository(),
task.result.getException() );
}
}
return results;
}
|
597631_0
|
public SimpleGapPenalty() {
this(dgop, dgep);
}
|
597631_1
|
@Override
public Type getType() {
return type;
}
|
597631_2
|
public NeedlemanWunsch() {
}
|
597631_3
|
public GuideTree(List<S> sequences, List<PairwiseSequenceScorer<S, C>> scorers) {
this.sequences = Collections.unmodifiableList(sequences);
this.scorers = Collections.unmodifiableList(scorers);
distances = new BasicSymmetricalDistanceMatrix(sequences.size());
BasicSymmetricalDistanceMatrix distclone = new BasicSymmetricalDistanceMatrix(sequences.size());
for (int i = 0, n = 0; i < sequences.size(); i++) {
AccessionID id = sequences.get(i).getAccession();
String str = (id == null) ? Integer.toString(i + 1) : id.getID();
distances.setIdentifier(i, str);
distclone.setIdentifier(i, str);
for (int j = i+1; j < sequences.size(); j++) {
double dist = scorers.get(n++).getDistance();
distances.setValue(i, j, dist);
distclone.setValue(i, j, dist);
}
}
// TODO UPGMA and other hierarchical clustering routines
Phylogeny phylogeny = NeighborJoining.createInstance().execute(distclone);
newick = phylogeny.toString();
root = new Node(phylogeny.getRoot(), null);
}
|
597631_4
|
public int[] getAllPairsScores() {
int[] scores = new int[scorers.size()];
int n = 0;
for (PairwiseSequenceScorer<S, C> scorer : scorers) {
scores[n++] = scorer.getScore();
}
return scores;
}
|
597631_5
|
public double[][] getDistanceMatrix() {
double[][] matrix = new double[distances.getSize()][distances.getSize()];
for (int i = 0; i < matrix.length; i++) {
for (int j = i+1; j < matrix.length; j++) {
matrix[i][j] = matrix[j][i] = distances.getValue(i, j);
}
}
return matrix;
}
|
597631_6
|
public Node getRoot() {
return root;
}
|
597631_7
|
public int[][] getScoreMatrix() {
int[][] matrix = new int[sequences.size()][sequences.size()];
for (int i = 0, n = 0; i < matrix.length; i++) {
matrix[i][i] = scorers.get(i).getMaxScore();
for (int j = i+1; j < matrix.length; j++) {
matrix[i][j] = matrix[j][i] = scorers.get(n++).getScore();
}
}
return matrix;
}
|
597631_8
|
public List<S> getSequences() {
return sequences;
}
|
597631_9
|
@Override
public Iterator<GuideTreeNode<S, C>> iterator() {
return new PostOrderIterator();
}
|
608316_0
|
@Override
public void put(K key, T obj) throws IOException {
getDatumWriter().write(obj, getEncoder());
}
|
608316_1
|
@Override
public void close() throws IOException {
super.close();
if(encoder != null) {
encoder.flush();
}
encoder = null;
decoder = null;
}
|
608316_2
|
public static byte[] readFully(InputStream in) throws IOException {
List<ByteBuffer> buffers = new ArrayList<ByteBuffer>(4);
while(true) {
ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);
int count = in.read(buffer.array(), 0, BUFFER_SIZE);
if(count > 0) {
buffer.limit(count);
buffers.add(buffer);
}
if(count < BUFFER_SIZE) break;
}
return getAsBytes(buffers);
}
|
608316_3
|
@Override
public void setLimit(long limit) {
baseQuery.setLimit(limit);
}
|
608316_4
|
@SuppressWarnings("unchecked")
public static <D extends DataStore<K,T>, K, T extends Persistent>
D getDataStore( Class<D> dataStoreClass, Class<K> keyClass,
Class<T> persistentClass) {
int hash = getDataStoreKey(dataStoreClass, keyClass, persistentClass);
D dataStore = (D) dataStores.get(hash);
if(dataStore == null) {
dataStore = createDataStore(dataStoreClass, keyClass, persistentClass
, properties);
dataStores.put(hash, dataStore);
}
return dataStore;
}
|
608316_5
|
@SuppressWarnings("unchecked")
public static <D extends DataStore<K,T>, K, T extends Persistent>
D getDataStore( Class<D> dataStoreClass, Class<K> keyClass,
Class<T> persistentClass) {
int hash = getDataStoreKey(dataStoreClass, keyClass, persistentClass);
D dataStore = (D) dataStores.get(hash);
if(dataStore == null) {
dataStore = createDataStore(dataStoreClass, keyClass, persistentClass
, properties);
dataStores.put(hash, dataStore);
}
return dataStore;
}
|
608316_6
|
@SuppressWarnings("unchecked")
public static <D extends DataStore<K,T>, K, T extends Persistent>
D getDataStore( Class<D> dataStoreClass, Class<K> keyClass,
Class<T> persistentClass) {
int hash = getDataStoreKey(dataStoreClass, keyClass, persistentClass);
D dataStore = (D) dataStores.get(hash);
if(dataStore == null) {
dataStore = createDataStore(dataStoreClass, keyClass, persistentClass
, properties);
dataStores.put(hash, dataStore);
}
return dataStore;
}
|
608316_7
|
@SuppressWarnings("unchecked")
public static <D extends DataStore<K,T>, K, T extends Persistent>
D getDataStore( Class<D> dataStoreClass, Class<K> keyClass,
Class<T> persistentClass) {
int hash = getDataStoreKey(dataStoreClass, keyClass, persistentClass);
D dataStore = (D) dataStores.get(hash);
if(dataStore == null) {
dataStore = createDataStore(dataStoreClass, keyClass, persistentClass
, properties);
dataStores.put(hash, dataStore);
}
return dataStore;
}
|
608316_8
|
private static Properties readProperties() throws IOException {
Properties properties = new Properties();
if(propertiesFile != null) {
InputStream stream = DataStoreFactory.class.getClassLoader()
.getResourceAsStream(propertiesFile);
if(stream != null) {
try {
properties.load(stream);
setProperties(properties);
return properties;
} finally {
stream.close();
}
}
}
log.warn("Gora properties are not loaded!");
return null;
}
|
608316_9
|
public static String findProperty(Properties properties
, DataStore<?, ?> store, String baseKey, String defaultValue) {
//recursively try the class names until the base class
Class<?> clazz = store.getClass();
while(true) {
String fullKey = GORA + "." + org.gora.util.StringUtils.getClassname(clazz) + "." + baseKey;
String value = getProperty(properties, fullKey);
if(value != null) {
return value;
}
//try once with lowercase
value = getProperty(properties, fullKey.toLowerCase());
if(value != null) {
return value;
}
if(clazz.equals(DataStoreBase.class)) {
break;
}
clazz = clazz.getSuperclass();
if(clazz == null) {
break;
}
}
//try with "datastore"
String fullKey = GORA + "." + DATASTORE + "." + baseKey;
String value = getProperty(properties, fullKey);
if(value != null) {
return value;
}
return defaultValue;
}
|
608843_0
|
public static Unsafe getUnsafe() {
/*
* Only code on the bootclasspath is allowed to get at the
* Unsafe instance.
*/
ClassLoader calling = VMStack.getCallingClassLoader();
if ((calling != null) && (calling != Unsafe.class.getClassLoader())) {
throw new SecurityException("Unsafe access denied");
}
return THE_ONE;
}
|
608843_1
|
public static Unsafe getUnsafe() {
/*
* Only code on the bootclasspath is allowed to get at the
* Unsafe instance.
*/
ClassLoader calling = VMStack.getCallingClassLoader();
if ((calling != null) && (calling != Unsafe.class.getClassLoader())) {
throw new SecurityException("Unsafe access denied");
}
return THE_ONE;
}
|
608843_2
|
;
|
608843_3
|
public native void setIntArray(int address, int[] ints, int offset,
throws NullPointerException,
;
|
608843_4
|
public native void setShortArray(int address, short[] shorts, int offset,
throws NullPointerException,
;
|
618103_0
|
@Override
protected Void doInBackground(final String... args) {
errors = new ArrayList<>();
List<Bank> banks;
if (bankId != -1) {
banks = new ArrayList<>();
banks.add(getBankFromDb(bankId, parent));
} else {
banks = getBanksFromDb(parent);
}
getDialog().setMax(banks.size());
int i = 0;
for (final Bank bank : banks) {
publishProgress(i, bank);
if (isListingAllBanks() && bank.isDisabled()) {
LoggingUtils.logDisabledBank(bank);
continue;
}
try {
bank.update();
bank.updateAllTransactions();
bank.closeConnection();
saveBank(bank, parent);
i++;
LoggingUtils.logBankUpdate(bank, true);
} catch (final BankException e) {
this.errors.add(bank.getName() + " (" + bank.getUsername()
+ ")");
Timber.e(e, "Could not update bank.");
} catch (final LoginException e) {
this.errors.add(bank.getName() + " (" + bank.getUsername()
+ ")");
DBAdapter.disable(bank, parent);
} catch (BankChoiceException e) {
this.errors.add(bank.getName() + " (" + bank.getUsername()
+ ")");
} catch (IOException e) {
this.errors.add(bank.getName() + " (" + bank.getUsername()
+ ")");
if (NetworkUtils.isInternetAvailable()) {
Timber.e(e, "IO error talking to bank");
}
}
if (isContentProviderEnabled()) {
final ArrayList<Account> accounts = bank.getAccounts();
for (final Account account : accounts) {
AutoRefreshService.broadcastTransactionUpdate(parent,
bank.getDbId(), account.getId());
}
}
}
publishProgress(i, null);
return null;
}
|
618103_1
|
@Override
protected Void doInBackground(final String... args) {
errors = new ArrayList<>();
List<Bank> banks;
if (bankId != -1) {
banks = new ArrayList<>();
banks.add(getBankFromDb(bankId, parent));
} else {
banks = getBanksFromDb(parent);
}
getDialog().setMax(banks.size());
int i = 0;
for (final Bank bank : banks) {
publishProgress(i, bank);
if (isListingAllBanks() && bank.isDisabled()) {
LoggingUtils.logDisabledBank(bank);
continue;
}
try {
bank.update();
bank.updateAllTransactions();
bank.closeConnection();
saveBank(bank, parent);
i++;
LoggingUtils.logBankUpdate(bank, true);
} catch (final BankException e) {
this.errors.add(bank.getName() + " (" + bank.getUsername()
+ ")");
Timber.e(e, "Could not update bank.");
} catch (final LoginException e) {
this.errors.add(bank.getName() + " (" + bank.getUsername()
+ ")");
DBAdapter.disable(bank, parent);
} catch (BankChoiceException e) {
this.errors.add(bank.getName() + " (" + bank.getUsername()
+ ")");
} catch (IOException e) {
this.errors.add(bank.getName() + " (" + bank.getUsername()
+ ")");
if (NetworkUtils.isInternetAvailable()) {
Timber.e(e, "IO error talking to bank");
}
}
if (isContentProviderEnabled()) {
final ArrayList<Account> accounts = bank.getAccounts();
for (final Account account : accounts) {
AutoRefreshService.broadcastTransactionUpdate(parent,
bank.getDbId(), account.getId());
}
}
}
publishProgress(i, null);
return null;
}
|
618103_2
|
@Override
protected Void doInBackground(final String... args) {
errors = new ArrayList<>();
List<Bank> banks;
if (bankId != -1) {
banks = new ArrayList<>();
banks.add(getBankFromDb(bankId, parent));
} else {
banks = getBanksFromDb(parent);
}
getDialog().setMax(banks.size());
int i = 0;
for (final Bank bank : banks) {
publishProgress(i, bank);
if (isListingAllBanks() && bank.isDisabled()) {
LoggingUtils.logDisabledBank(bank);
continue;
}
try {
bank.update();
bank.updateAllTransactions();
bank.closeConnection();
saveBank(bank, parent);
i++;
LoggingUtils.logBankUpdate(bank, true);
} catch (final BankException e) {
this.errors.add(bank.getName() + " (" + bank.getUsername()
+ ")");
Timber.e(e, "Could not update bank.");
} catch (final LoginException e) {
this.errors.add(bank.getName() + " (" + bank.getUsername()
+ ")");
DBAdapter.disable(bank, parent);
} catch (BankChoiceException e) {
this.errors.add(bank.getName() + " (" + bank.getUsername()
+ ")");
} catch (IOException e) {
this.errors.add(bank.getName() + " (" + bank.getUsername()
+ ")");
if (NetworkUtils.isInternetAvailable()) {
Timber.e(e, "IO error talking to bank");
}
}
if (isContentProviderEnabled()) {
final ArrayList<Account> accounts = bank.getAccounts();
for (final Account account : accounts) {
AutoRefreshService.broadcastTransactionUpdate(parent,
bank.getDbId(), account.getId());
}
}
}
publishProgress(i, null);
return null;
}
|
618103_3
|
@Override
protected Void doInBackground(final String... args) {
errors = new ArrayList<>();
List<Bank> banks;
if (bankId != -1) {
banks = new ArrayList<>();
banks.add(getBankFromDb(bankId, parent));
} else {
banks = getBanksFromDb(parent);
}
getDialog().setMax(banks.size());
int i = 0;
for (final Bank bank : banks) {
publishProgress(i, bank);
if (isListingAllBanks() && bank.isDisabled()) {
LoggingUtils.logDisabledBank(bank);
continue;
}
try {
bank.update();
bank.updateAllTransactions();
bank.closeConnection();
saveBank(bank, parent);
i++;
LoggingUtils.logBankUpdate(bank, true);
} catch (final BankException e) {
this.errors.add(bank.getName() + " (" + bank.getUsername()
+ ")");
Timber.e(e, "Could not update bank.");
} catch (final LoginException e) {
this.errors.add(bank.getName() + " (" + bank.getUsername()
+ ")");
DBAdapter.disable(bank, parent);
} catch (BankChoiceException e) {
this.errors.add(bank.getName() + " (" + bank.getUsername()
+ ")");
} catch (IOException e) {
this.errors.add(bank.getName() + " (" + bank.getUsername()
+ ")");
if (NetworkUtils.isInternetAvailable()) {
Timber.e(e, "IO error talking to bank");
}
}
if (isContentProviderEnabled()) {
final ArrayList<Account> accounts = bank.getAccounts();
for (final Account account : accounts) {
AutoRefreshService.broadcastTransactionUpdate(parent,
bank.getDbId(), account.getId());
}
}
}
publishProgress(i, null);
return null;
}
|
618103_4
|
public static void blameBankdroid(Throwable exception) {
Throwable ultimateCause = getUltimateCause(exception);
if (ultimateCause == null) {
// Unable to find ultimate cause, never mind
return;
}
StackTraceElement[] bankdroidifiedStacktrace =
bankdroidifyStacktrace(ultimateCause.getStackTrace());
if (bankdroidifiedStacktrace.length == 0) {
// No Bankdroid stack frames found, never mind
return;
}
if (bankdroidifiedStacktrace.length == ultimateCause.getStackTrace().length) {
// Bankdroid already to blame, never mind
return;
}
Throwable fakeCause = cloneException(ultimateCause);
if (fakeCause == null) {
Timber.w(new RuntimeException(
"Unable to bankdroidify exception of class: " + ultimateCause.getClass()));
return;
}
// Put the bankdroidified stack trace before the fakeCause's actual stack trace
fakeCause.setStackTrace(concatArrays(bankdroidifiedStacktrace, fakeCause.getStackTrace()));
ultimateCause.initCause(fakeCause);
}
|
618103_5
|
public static void blameBankdroid(Throwable exception) {
Throwable ultimateCause = getUltimateCause(exception);
if (ultimateCause == null) {
// Unable to find ultimate cause, never mind
return;
}
StackTraceElement[] bankdroidifiedStacktrace =
bankdroidifyStacktrace(ultimateCause.getStackTrace());
if (bankdroidifiedStacktrace.length == 0) {
// No Bankdroid stack frames found, never mind
return;
}
if (bankdroidifiedStacktrace.length == ultimateCause.getStackTrace().length) {
// Bankdroid already to blame, never mind
return;
}
Throwable fakeCause = cloneException(ultimateCause);
if (fakeCause == null) {
Timber.w(new RuntimeException(
"Unable to bankdroidify exception of class: " + ultimateCause.getClass()));
return;
}
// Put the bankdroidified stack trace before the fakeCause's actual stack trace
fakeCause.setStackTrace(concatArrays(bankdroidifiedStacktrace, fakeCause.getStackTrace()));
ultimateCause.initCause(fakeCause);
}
|
618103_6
|
public static void blameBankdroid(Throwable exception) {
Throwable ultimateCause = getUltimateCause(exception);
if (ultimateCause == null) {
// Unable to find ultimate cause, never mind
return;
}
StackTraceElement[] bankdroidifiedStacktrace =
bankdroidifyStacktrace(ultimateCause.getStackTrace());
if (bankdroidifiedStacktrace.length == 0) {
// No Bankdroid stack frames found, never mind
return;
}
if (bankdroidifiedStacktrace.length == ultimateCause.getStackTrace().length) {
// Bankdroid already to blame, never mind
return;
}
Throwable fakeCause = cloneException(ultimateCause);
if (fakeCause == null) {
Timber.w(new RuntimeException(
"Unable to bankdroidify exception of class: " + ultimateCause.getClass()));
return;
}
// Put the bankdroidified stack trace before the fakeCause's actual stack trace
fakeCause.setStackTrace(concatArrays(bankdroidifiedStacktrace, fakeCause.getStackTrace()));
ultimateCause.initCause(fakeCause);
}
|
618103_7
|
@VisibleForTesting
@NonNull
static StackTraceElement[] bankdroidifyStacktrace(final StackTraceElement[] rawStack) {
for (int i = 0; i < rawStack.length; i++) {
StackTraceElement stackTraceElement = rawStack[i];
if (stackTraceElement.getClassName().startsWith(PREFIX)) {
return Arrays.copyOfRange(rawStack, i, rawStack.length);
}
}
// No Bankdroid stack frames found, never mind
return new StackTraceElement[0];
}
|
618103_8
|
@Nullable
@VisibleForTesting
static <T extends Throwable> T cloneException(T wrapMe) {
Class<?> newClass = wrapMe.getClass();
while (newClass != null) {
try {
T returnMe =
(T) newClass.getConstructor(String.class).newInstance(wrapMe.getMessage());
returnMe.setStackTrace(wrapMe.getStackTrace());
return returnMe;
} catch (InvocationTargetException e) {
newClass = newClass.getSuperclass();
} catch (NoSuchMethodException e) {
newClass = newClass.getSuperclass();
} catch (InstantiationException e) {
newClass = newClass.getSuperclass();
} catch (IllegalAccessException e) {
newClass = newClass.getSuperclass();
}
}
return null;
}
|
618103_9
|
@Nullable
@VisibleForTesting
static <T extends Throwable> T cloneException(T wrapMe) {
Class<?> newClass = wrapMe.getClass();
while (newClass != null) {
try {
T returnMe =
(T) newClass.getConstructor(String.class).newInstance(wrapMe.getMessage());
returnMe.setStackTrace(wrapMe.getStackTrace());
return returnMe;
} catch (InvocationTargetException e) {
newClass = newClass.getSuperclass();
} catch (NoSuchMethodException e) {
newClass = newClass.getSuperclass();
} catch (InstantiationException e) {
newClass = newClass.getSuperclass();
} catch (IllegalAccessException e) {
newClass = newClass.getSuperclass();
}
}
return null;
}
|
618492_0
|
public static String updateUrl(String url, Properties props) {
String result = url;
// max connections.
final String maxConnections =
props.getProperty("mongodb.maxconnections", UNAVAILABLE).toLowerCase();
if (!UNAVAILABLE.equals(maxConnections)) {
result = addUrlOption(result, "maxPoolSize", maxConnections);
}
// Blocked thread multiplier.
final String threadsAllowedToBlockForConnectionMultiplier =
props
.getProperty(
"mongodb.threadsAllowedToBlockForConnectionMultiplier",
UNAVAILABLE).toLowerCase();
if (!UNAVAILABLE.equals(threadsAllowedToBlockForConnectionMultiplier)) {
result =
addUrlOption(result, "waitQueueMultiple",
threadsAllowedToBlockForConnectionMultiplier);
}
// write concern
String writeConcernType =
props.getProperty("mongodb.writeConcern", UNAVAILABLE).toLowerCase();
if (!UNAVAILABLE.equals(writeConcernType)) {
if ("errors_ignored".equals(writeConcernType)) {
result = addUrlOption(result, "w", "0");
} else if ("unacknowledged".equals(writeConcernType)) {
result = addUrlOption(result, "w", "0");
} else if ("acknowledged".equals(writeConcernType)) {
result = addUrlOption(result, "w", "1");
} else if ("journaled".equals(writeConcernType)) {
result = addUrlOption(result, "journal", "true"); // this is the
// documented option
// name
result = addUrlOption(result, "j", "true"); // but keep this until
// MongoDB Java driver
// supports "journal" option
} else if ("replica_acknowledged".equals(writeConcernType)) {
result = addUrlOption(result, "w", "2");
} else if ("majority".equals(writeConcernType)) {
result = addUrlOption(result, "w", "majority");
} else {
System.err.println("WARNING: Invalid writeConcern: '"
+ writeConcernType + "' will be ignored. "
+ "Must be one of [ unacknowledged | acknowledged | "
+ "journaled | replica_acknowledged | majority ]");
}
}
// read preference
String readPreferenceType =
props.getProperty("mongodb.readPreference", UNAVAILABLE).toLowerCase();
if (!UNAVAILABLE.equals(readPreferenceType)) {
if ("primary".equals(readPreferenceType)) {
result = addUrlOption(result, "readPreference", "primary");
} else if ("primary_preferred".equals(readPreferenceType)) {
result = addUrlOption(result, "readPreference", "primaryPreferred");
} else if ("secondary".equals(readPreferenceType)) {
result = addUrlOption(result, "readPreference", "secondary");
} else if ("secondary_preferred".equals(readPreferenceType)) {
result = addUrlOption(result, "readPreference", "secondaryPreferred");
} else if ("nearest".equals(readPreferenceType)) {
result = addUrlOption(result, "readPreference", "nearest");
} else {
System.err.println("WARNING: Invalid readPreference: '"
+ readPreferenceType + "' will be ignored. "
+ "Must be one of [ primary | primary_preferred | "
+ "secondary | secondary_preferred | nearest ]");
}
}
return result;
}
|
618492_1
|
public static String updateUrl(String url, Properties props) {
String result = url;
// max connections.
final String maxConnections =
props.getProperty("mongodb.maxconnections", UNAVAILABLE).toLowerCase();
if (!UNAVAILABLE.equals(maxConnections)) {
result = addUrlOption(result, "maxPoolSize", maxConnections);
}
// Blocked thread multiplier.
final String threadsAllowedToBlockForConnectionMultiplier =
props
.getProperty(
"mongodb.threadsAllowedToBlockForConnectionMultiplier",
UNAVAILABLE).toLowerCase();
if (!UNAVAILABLE.equals(threadsAllowedToBlockForConnectionMultiplier)) {
result =
addUrlOption(result, "waitQueueMultiple",
threadsAllowedToBlockForConnectionMultiplier);
}
// write concern
String writeConcernType =
props.getProperty("mongodb.writeConcern", UNAVAILABLE).toLowerCase();
if (!UNAVAILABLE.equals(writeConcernType)) {
if ("errors_ignored".equals(writeConcernType)) {
result = addUrlOption(result, "w", "0");
} else if ("unacknowledged".equals(writeConcernType)) {
result = addUrlOption(result, "w", "0");
} else if ("acknowledged".equals(writeConcernType)) {
result = addUrlOption(result, "w", "1");
} else if ("journaled".equals(writeConcernType)) {
result = addUrlOption(result, "journal", "true"); // this is the
// documented option
// name
result = addUrlOption(result, "j", "true"); // but keep this until
// MongoDB Java driver
// supports "journal" option
} else if ("replica_acknowledged".equals(writeConcernType)) {
result = addUrlOption(result, "w", "2");
} else if ("majority".equals(writeConcernType)) {
result = addUrlOption(result, "w", "majority");
} else {
System.err.println("WARNING: Invalid writeConcern: '"
+ writeConcernType + "' will be ignored. "
+ "Must be one of [ unacknowledged | acknowledged | "
+ "journaled | replica_acknowledged | majority ]");
}
}
// read preference
String readPreferenceType =
props.getProperty("mongodb.readPreference", UNAVAILABLE).toLowerCase();
if (!UNAVAILABLE.equals(readPreferenceType)) {
if ("primary".equals(readPreferenceType)) {
result = addUrlOption(result, "readPreference", "primary");
} else if ("primary_preferred".equals(readPreferenceType)) {
result = addUrlOption(result, "readPreference", "primaryPreferred");
} else if ("secondary".equals(readPreferenceType)) {
result = addUrlOption(result, "readPreference", "secondary");
} else if ("secondary_preferred".equals(readPreferenceType)) {
result = addUrlOption(result, "readPreference", "secondaryPreferred");
} else if ("nearest".equals(readPreferenceType)) {
result = addUrlOption(result, "readPreference", "nearest");
} else {
System.err.println("WARNING: Invalid readPreference: '"
+ readPreferenceType + "' will be ignored. "
+ "Must be one of [ primary | primary_preferred | "
+ "secondary | secondary_preferred | nearest ]");
}
}
return result;
}
|
618492_2
|
public static String updateUrl(String url, Properties props) {
String result = url;
// max connections.
final String maxConnections =
props.getProperty("mongodb.maxconnections", UNAVAILABLE).toLowerCase();
if (!UNAVAILABLE.equals(maxConnections)) {
result = addUrlOption(result, "maxPoolSize", maxConnections);
}
// Blocked thread multiplier.
final String threadsAllowedToBlockForConnectionMultiplier =
props
.getProperty(
"mongodb.threadsAllowedToBlockForConnectionMultiplier",
UNAVAILABLE).toLowerCase();
if (!UNAVAILABLE.equals(threadsAllowedToBlockForConnectionMultiplier)) {
result =
addUrlOption(result, "waitQueueMultiple",
threadsAllowedToBlockForConnectionMultiplier);
}
// write concern
String writeConcernType =
props.getProperty("mongodb.writeConcern", UNAVAILABLE).toLowerCase();
if (!UNAVAILABLE.equals(writeConcernType)) {
if ("errors_ignored".equals(writeConcernType)) {
result = addUrlOption(result, "w", "0");
} else if ("unacknowledged".equals(writeConcernType)) {
result = addUrlOption(result, "w", "0");
} else if ("acknowledged".equals(writeConcernType)) {
result = addUrlOption(result, "w", "1");
} else if ("journaled".equals(writeConcernType)) {
result = addUrlOption(result, "journal", "true"); // this is the
// documented option
// name
result = addUrlOption(result, "j", "true"); // but keep this until
// MongoDB Java driver
// supports "journal" option
} else if ("replica_acknowledged".equals(writeConcernType)) {
result = addUrlOption(result, "w", "2");
} else if ("majority".equals(writeConcernType)) {
result = addUrlOption(result, "w", "majority");
} else {
System.err.println("WARNING: Invalid writeConcern: '"
+ writeConcernType + "' will be ignored. "
+ "Must be one of [ unacknowledged | acknowledged | "
+ "journaled | replica_acknowledged | majority ]");
}
}
// read preference
String readPreferenceType =
props.getProperty("mongodb.readPreference", UNAVAILABLE).toLowerCase();
if (!UNAVAILABLE.equals(readPreferenceType)) {
if ("primary".equals(readPreferenceType)) {
result = addUrlOption(result, "readPreference", "primary");
} else if ("primary_preferred".equals(readPreferenceType)) {
result = addUrlOption(result, "readPreference", "primaryPreferred");
} else if ("secondary".equals(readPreferenceType)) {
result = addUrlOption(result, "readPreference", "secondary");
} else if ("secondary_preferred".equals(readPreferenceType)) {
result = addUrlOption(result, "readPreference", "secondaryPreferred");
} else if ("nearest".equals(readPreferenceType)) {
result = addUrlOption(result, "readPreference", "nearest");
} else {
System.err.println("WARNING: Invalid readPreference: '"
+ readPreferenceType + "' will be ignored. "
+ "Must be one of [ primary | primary_preferred | "
+ "secondary | secondary_preferred | nearest ]");
}
}
return result;
}
|
618492_3
|
public static String updateUrl(String url, Properties props) {
String result = url;
// max connections.
final String maxConnections =
props.getProperty("mongodb.maxconnections", UNAVAILABLE).toLowerCase();
if (!UNAVAILABLE.equals(maxConnections)) {
result = addUrlOption(result, "maxPoolSize", maxConnections);
}
// Blocked thread multiplier.
final String threadsAllowedToBlockForConnectionMultiplier =
props
.getProperty(
"mongodb.threadsAllowedToBlockForConnectionMultiplier",
UNAVAILABLE).toLowerCase();
if (!UNAVAILABLE.equals(threadsAllowedToBlockForConnectionMultiplier)) {
result =
addUrlOption(result, "waitQueueMultiple",
threadsAllowedToBlockForConnectionMultiplier);
}
// write concern
String writeConcernType =
props.getProperty("mongodb.writeConcern", UNAVAILABLE).toLowerCase();
if (!UNAVAILABLE.equals(writeConcernType)) {
if ("errors_ignored".equals(writeConcernType)) {
result = addUrlOption(result, "w", "0");
} else if ("unacknowledged".equals(writeConcernType)) {
result = addUrlOption(result, "w", "0");
} else if ("acknowledged".equals(writeConcernType)) {
result = addUrlOption(result, "w", "1");
} else if ("journaled".equals(writeConcernType)) {
result = addUrlOption(result, "journal", "true"); // this is the
// documented option
// name
result = addUrlOption(result, "j", "true"); // but keep this until
// MongoDB Java driver
// supports "journal" option
} else if ("replica_acknowledged".equals(writeConcernType)) {
result = addUrlOption(result, "w", "2");
} else if ("majority".equals(writeConcernType)) {
result = addUrlOption(result, "w", "majority");
} else {
System.err.println("WARNING: Invalid writeConcern: '"
+ writeConcernType + "' will be ignored. "
+ "Must be one of [ unacknowledged | acknowledged | "
+ "journaled | replica_acknowledged | majority ]");
}
}
// read preference
String readPreferenceType =
props.getProperty("mongodb.readPreference", UNAVAILABLE).toLowerCase();
if (!UNAVAILABLE.equals(readPreferenceType)) {
if ("primary".equals(readPreferenceType)) {
result = addUrlOption(result, "readPreference", "primary");
} else if ("primary_preferred".equals(readPreferenceType)) {
result = addUrlOption(result, "readPreference", "primaryPreferred");
} else if ("secondary".equals(readPreferenceType)) {
result = addUrlOption(result, "readPreference", "secondary");
} else if ("secondary_preferred".equals(readPreferenceType)) {
result = addUrlOption(result, "readPreference", "secondaryPreferred");
} else if ("nearest".equals(readPreferenceType)) {
result = addUrlOption(result, "readPreference", "nearest");
} else {
System.err.println("WARNING: Invalid readPreference: '"
+ readPreferenceType + "' will be ignored. "
+ "Must be one of [ primary | primary_preferred | "
+ "secondary | secondary_preferred | nearest ]");
}
}
return result;
}
|
618492_4
|
@Override
public Status read(String table, String endpoint, Set<String> fields, Map<String, ByteIterator> result) {
int responseCode;
try {
responseCode = httpGet(urlPrefix + endpoint, result);
} catch (Exception e) {
responseCode = handleExceptions(e, urlPrefix + endpoint, HttpMethod.GET);
}
if (logEnabled) {
System.err.println(new StringBuilder("GET Request: ").append(urlPrefix).append(endpoint)
.append(" | Response Code: ").append(responseCode).toString());
}
return getStatus(responseCode);
}
|
618492_5
|
@Override
public Status read(String table, String endpoint, Set<String> fields, Map<String, ByteIterator> result) {
int responseCode;
try {
responseCode = httpGet(urlPrefix + endpoint, result);
} catch (Exception e) {
responseCode = handleExceptions(e, urlPrefix + endpoint, HttpMethod.GET);
}
if (logEnabled) {
System.err.println(new StringBuilder("GET Request: ").append(urlPrefix).append(endpoint)
.append(" | Response Code: ").append(responseCode).toString());
}
return getStatus(responseCode);
}
|
618492_6
|
@Override
public Status read(String table, String endpoint, Set<String> fields, Map<String, ByteIterator> result) {
int responseCode;
try {
responseCode = httpGet(urlPrefix + endpoint, result);
} catch (Exception e) {
responseCode = handleExceptions(e, urlPrefix + endpoint, HttpMethod.GET);
}
if (logEnabled) {
System.err.println(new StringBuilder("GET Request: ").append(urlPrefix).append(endpoint)
.append(" | Response Code: ").append(responseCode).toString());
}
return getStatus(responseCode);
}
|
618492_7
|
@Override
public Status read(String table, String endpoint, Set<String> fields, Map<String, ByteIterator> result) {
int responseCode;
try {
responseCode = httpGet(urlPrefix + endpoint, result);
} catch (Exception e) {
responseCode = handleExceptions(e, urlPrefix + endpoint, HttpMethod.GET);
}
if (logEnabled) {
System.err.println(new StringBuilder("GET Request: ").append(urlPrefix).append(endpoint)
.append(" | Response Code: ").append(responseCode).toString());
}
return getStatus(responseCode);
}
|
618492_8
|
@Override
public Status insert(String table, String endpoint, Map<String, ByteIterator> values) {
int responseCode;
try {
responseCode = httpExecute(new HttpPost(urlPrefix + endpoint), values.get("data").toString());
} catch (Exception e) {
responseCode = handleExceptions(e, urlPrefix + endpoint, HttpMethod.POST);
}
if (logEnabled) {
System.err.println(new StringBuilder("POST Request: ").append(urlPrefix).append(endpoint)
.append(" | Response Code: ").append(responseCode).toString());
}
return getStatus(responseCode);
}
|
618492_9
|
@Override
public Status insert(String table, String endpoint, Map<String, ByteIterator> values) {
int responseCode;
try {
responseCode = httpExecute(new HttpPost(urlPrefix + endpoint), values.get("data").toString());
} catch (Exception e) {
responseCode = handleExceptions(e, urlPrefix + endpoint, HttpMethod.POST);
}
if (logEnabled) {
System.err.println(new StringBuilder("POST Request: ").append(urlPrefix).append(endpoint)
.append(" | Response Code: ").append(responseCode).toString());
}
return getStatus(responseCode);
}
|
618681_0
|
public String enhance(String input, String lang) {
if (input == null) return null;
if (input.isEmpty()) return "";
if (lang == null || lang.isEmpty()) return input;
List<String> rules = loader.loadNBSP(lang);
if (rules == null) return input;
for (String r : rules) {
Matcher m = Pattern.compile(r).matcher(input);
if (m.groupCount() != 3) {
throw new IllegalArgumentException("Expression must contain exactly 3 groups! " + r);
}
if (m.find()) {
input = m.replaceAll("$1\u00A0$3");
}
}
return input;
}
|
618681_1
|
public String enhance(String input, String lang) {
if (input == null) return null;
if (input.isEmpty()) return "";
if (lang == null || lang.isEmpty()) return input;
List<String> rules = loader.loadNBSP(lang);
if (rules == null) return input;
for (String r : rules) {
Matcher m = Pattern.compile(r).matcher(input);
if (m.groupCount() != 3) {
throw new IllegalArgumentException("Expression must contain exactly 3 groups! " + r);
}
if (m.find()) {
input = m.replaceAll("$1\u00A0$3");
}
}
return input;
}
|
618681_2
|
public String enhance(String input, String lang) {
if (input == null) return null;
if (input.isEmpty()) return "";
if (lang == null || lang.isEmpty()) return input;
List<String> rules = loader.loadNBSP(lang);
if (rules == null) return input;
for (String r : rules) {
Matcher m = Pattern.compile(r).matcher(input);
if (m.groupCount() != 3) {
throw new IllegalArgumentException("Expression must contain exactly 3 groups! " + r);
}
if (m.find()) {
input = m.replaceAll("$1\u00A0$3");
}
}
return input;
}
|
618681_3
|
public String enhance(String input, String lang) {
if (input == null) return null;
if (input.isEmpty()) return "";
if (lang == null || lang.isEmpty()) return input;
List<String> rules = loader.loadNBSP(lang);
if (rules == null) return input;
for (String r : rules) {
Matcher m = Pattern.compile(r).matcher(input);
if (m.groupCount() != 3) {
throw new IllegalArgumentException("Expression must contain exactly 3 groups! " + r);
}
if (m.find()) {
input = m.replaceAll("$1\u00A0$3");
}
}
return input;
}
|
618681_4
|
public String enhance(String input, String lang) {
if (input == null) return null;
if (input.isEmpty()) return "";
if (lang == null || lang.isEmpty()) return input;
List<String> rules = loader.loadNBSP(lang);
if (rules == null) return input;
for (String r : rules) {
Matcher m = Pattern.compile(r).matcher(input);
if (m.groupCount() != 3) {
throw new IllegalArgumentException("Expression must contain exactly 3 groups! " + r);
}
if (m.find()) {
input = m.replaceAll("$1\u00A0$3");
}
}
return input;
}
|
618681_5
|
public String enhance(String input, String lang) {
if (input == null) return null;
if (input.isEmpty()) return "";
if (lang == null || lang.isEmpty()) return input;
List<String> rules = loader.loadNBSP(lang);
if (rules == null) return input;
for (String r : rules) {
Matcher m = Pattern.compile(r).matcher(input);
if (m.groupCount() != 3) {
throw new IllegalArgumentException("Expression must contain exactly 3 groups! " + r);
}
if (m.find()) {
input = m.replaceAll("$1\u00A0$3");
}
}
return input;
}
|
618681_6
|
@Override
public List<String> loadNBSP(String lang) {
if (lang == null || lang.isEmpty()) {
throw new IllegalArgumentException("Lang must be filled to search for file!");
}
List<String> result = loadForKey(lang);
if (result == null) {
int index = lang.indexOf('_');
if (index < 0) return null; // cannot split key
result = loadForKey(lang.substring(0, index));
}
return result;
}
|
618681_7
|
@Override
public List<String> loadNBSP(String lang) {
if (lang == null || lang.isEmpty()) {
throw new IllegalArgumentException("Lang must be filled to search for file!");
}
List<String> result = loadForKey(lang);
if (result == null) {
int index = lang.indexOf('_');
if (index < 0) return null; // cannot split key
result = loadForKey(lang.substring(0, index));
}
return result;
}
|
618681_8
|
@Override
public List<String> loadNBSP(String lang) {
if (lang == null || lang.isEmpty()) {
throw new IllegalArgumentException("Lang must be filled to search for file!");
}
List<String> result = loadForKey(lang);
if (result == null) {
int index = lang.indexOf('_');
if (index < 0) return null; // cannot split key
result = loadForKey(lang.substring(0, index));
}
return result;
}
|
618681_9
|
@Override
public List<String> loadNBSP(String lang) {
if (lang == null || lang.isEmpty()) {
throw new IllegalArgumentException("Lang must be filled to search for file!");
}
List<String> result = loadForKey(lang);
if (result == null) {
int index = lang.indexOf('_');
if (index < 0) return null; // cannot split key
result = loadForKey(lang.substring(0, index));
}
return result;
}
|
620505_0
|
private List<String> getHosts(List<NodeMetadata> nodes) {
return Lists.transform(Lists.newArrayList(nodes),
ew Function<NodeMetadata, String>() {
@Override
public String apply(NodeMetadata node) {
tring publicIp = Iterables.get(node.getPublicAddresses(), 0)
.getHostName();
eturn String.format("%s:%d", publicIp, CLIENT_PORT);
}
});
}
|
625665_0
|
protected void resize(int newcount) {
byte newbuf[] = new byte[Math.max(buf.length << 1, newcount)];
System.arraycopy(buf, 0, newbuf, 0, pos);
buf = newbuf;
}
|
643234_0
|
public void archive(File archive, File directory) {
try {
ArchiveOutputStream out = factory.createArchiveOutputStream(ARCHIVER_NAME,
new FileOutputStream(archive));
List<File> files = listContent(directory);
for (File file : files) {
if (!file.isDirectory()) {
ZipArchiveEntry entry = new ZipArchiveEntry(relativeTo(
file, directory).getPath());
zipEntry(entry, out, file);
}
}
out.close();
} catch (Exception e) {
throw new FileArchiveFailedException(archive, directory, e);
}
}
|
643234_1
|
public void delete(List<File> files) {
for (File file: files) {
deleteFile(file);
}
}
|
643234_2
|
public List<File> upload(List<FileItem> fileItems, List<String> errors) {
List<File> files = new ArrayList<File>();
File directory = uploadDirectory();
for (FileItem item : fileItems) {
try {
File file = writeItemToFile(directory, item);
monitor.fileUploaded(file);
files.add(file);
} catch (FileItemNameMissingException e) {
// ignore and carry on
} catch (FileWriteFailedException e) {
errors.add(e.getMessage());
if (e.getCause() != null) {
errors.add(e.getCause().getMessage());
}
monitor.fileUploadFailed(item, e);
}
}
return files;
}
|
643234_3
|
public String resourceAsString(String relativePath) {
String resourcePath = resolvePath(relativePath);
try {
try {
return classpathResource(resourcePath);
} catch (ResourceNotFoundException e) {
return filesystemResource(resourcePath);
}
} catch (IOException e) {
throw new ResourceRetrievalFailedException(resourcePath);
}
}
|
643234_4
|
public String resourceAsString(String relativePath) {
String resourcePath = resolvePath(relativePath);
try {
try {
return classpathResource(resourcePath);
} catch (ResourceNotFoundException e) {
return filesystemResource(resourcePath);
}
} catch (IOException e) {
throw new ResourceRetrievalFailedException(resourcePath);
}
}
|
643234_5
|
public String resourceAsString(String relativePath) {
String resourcePath = resolvePath(relativePath);
try {
try {
return classpathResource(resourcePath);
} catch (ResourceNotFoundException e) {
return filesystemResource(resourcePath);
}
} catch (IOException e) {
throw new ResourceRetrievalFailedException(resourcePath);
}
}
|
643234_6
|
public String resourceAsString(String relativePath) {
String resourcePath = resolvePath(relativePath);
try {
try {
return classpathResource(resourcePath);
} catch (ResourceNotFoundException e) {
return filesystemResource(resourcePath);
}
} catch (IOException e) {
throw new ResourceRetrievalFailedException(resourcePath);
}
}
|
643234_7
|
public String resourceAsString(String relativePath) {
String resourcePath = resolvePath(relativePath);
try {
try {
return classpathResource(resourcePath);
} catch (ResourceNotFoundException e) {
return filesystemResource(resourcePath);
}
} catch (IOException e) {
throw new ResourceRetrievalFailedException(resourcePath);
}
}
|
643234_8
|
public String resourceAsString(String relativePath) {
String resourcePath = resolvePath(relativePath);
try {
try {
return classpathResource(resourcePath);
} catch (ResourceNotFoundException e) {
return filesystemResource(resourcePath);
}
} catch (IOException e) {
throw new ResourceRetrievalFailedException(resourcePath);
}
}
|
643234_9
|
public String resourceAsString(String relativePath) {
String resourcePath = resolvePath(relativePath);
try {
try {
return classpathResource(resourcePath);
} catch (ResourceNotFoundException e) {
return filesystemResource(resourcePath);
}
} catch (IOException e) {
throw new ResourceRetrievalFailedException(resourcePath);
}
}
|
651333_0
|
public static Expression parse(String text) {
text = text.replaceAll("\\s*,\\s*", ",");
StringTokenizer st = new StringTokenizer(text, "$%,\'[])", true);
MethodExpression root = new MethodExpression("eval");
Stack<MethodExpression> stack = new Stack<MethodExpression>();
stack.push(root);
try {
while (st.hasMoreTokens()) {
String token = st.nextToken();
if (token.equals("%")) {
if (st.hasMoreTokens()) {
String s = st.nextToken();
s = Character.toUpperCase(s.charAt(0)) + s.substring(1);
stack.peek().addExpression(new ParameterExpression(s));
if (st.hasMoreTokens() && !st.nextToken().equals("%")) {
break;
}
}
} else if (token.equals("$")) {
if (st.hasMoreTokens()) {
String s = st.nextToken();
s = s.substring(0, s.length() - 1);
MethodExpression m = new MethodExpression(s);
stack.peek().addExpression(m);
stack.push(m);
}
} else if (token.equals(")") || token.equals("]")) {
stack.pop();
} else if (token.equals(",")) {
//ignore
} else if (token.equals("\'")) {
StringBuilder sb = new StringBuilder();
while (st.hasMoreTokens()) {
String str = st.nextToken();
if (str.equals("\'"))
break;
sb.append(str);
}
stack.peek().addExpression(new TextExpression(sb.toString()));
} else if (token.equals("[")) {
MethodExpression m = new MethodExpression("notNull");
stack.peek().addExpression(m);
stack.push(m);
} else {
stack.peek().addExpression(new TextExpression(token));
}
}
} catch (Exception e) {
e.printStackTrace();
}
ArrayList<Expression> e = root.getExpressions();
if (e.size() == 1) {
return e.get(0);
} else {
return root;
}
}
|
651333_1
|
public static Expression parse(String text) {
text = text.replaceAll("\\s*,\\s*", ",");
StringTokenizer st = new StringTokenizer(text, "$%,\'[])", true);
MethodExpression root = new MethodExpression("eval");
Stack<MethodExpression> stack = new Stack<MethodExpression>();
stack.push(root);
try {
while (st.hasMoreTokens()) {
String token = st.nextToken();
if (token.equals("%")) {
if (st.hasMoreTokens()) {
String s = st.nextToken();
s = Character.toUpperCase(s.charAt(0)) + s.substring(1);
stack.peek().addExpression(new ParameterExpression(s));
if (st.hasMoreTokens() && !st.nextToken().equals("%")) {
break;
}
}
} else if (token.equals("$")) {
if (st.hasMoreTokens()) {
String s = st.nextToken();
s = s.substring(0, s.length() - 1);
MethodExpression m = new MethodExpression(s);
stack.peek().addExpression(m);
stack.push(m);
}
} else if (token.equals(")") || token.equals("]")) {
stack.pop();
} else if (token.equals(",")) {
//ignore
} else if (token.equals("\'")) {
StringBuilder sb = new StringBuilder();
while (st.hasMoreTokens()) {
String str = st.nextToken();
if (str.equals("\'"))
break;
sb.append(str);
}
stack.peek().addExpression(new TextExpression(sb.toString()));
} else if (token.equals("[")) {
MethodExpression m = new MethodExpression("notNull");
stack.peek().addExpression(m);
stack.push(m);
} else {
stack.peek().addExpression(new TextExpression(token));
}
}
} catch (Exception e) {
e.printStackTrace();
}
ArrayList<Expression> e = root.getExpressions();
if (e.size() == 1) {
return e.get(0);
} else {
return root;
}
}
|
651333_2
|
public static Expression parse(String text) {
text = text.replaceAll("\\s*,\\s*", ",");
StringTokenizer st = new StringTokenizer(text, "$%,\'[])", true);
MethodExpression root = new MethodExpression("eval");
Stack<MethodExpression> stack = new Stack<MethodExpression>();
stack.push(root);
try {
while (st.hasMoreTokens()) {
String token = st.nextToken();
if (token.equals("%")) {
if (st.hasMoreTokens()) {
String s = st.nextToken();
s = Character.toUpperCase(s.charAt(0)) + s.substring(1);
stack.peek().addExpression(new ParameterExpression(s));
if (st.hasMoreTokens() && !st.nextToken().equals("%")) {
break;
}
}
} else if (token.equals("$")) {
if (st.hasMoreTokens()) {
String s = st.nextToken();
s = s.substring(0, s.length() - 1);
MethodExpression m = new MethodExpression(s);
stack.peek().addExpression(m);
stack.push(m);
}
} else if (token.equals(")") || token.equals("]")) {
stack.pop();
} else if (token.equals(",")) {
//ignore
} else if (token.equals("\'")) {
StringBuilder sb = new StringBuilder();
while (st.hasMoreTokens()) {
String str = st.nextToken();
if (str.equals("\'"))
break;
sb.append(str);
}
stack.peek().addExpression(new TextExpression(sb.toString()));
} else if (token.equals("[")) {
MethodExpression m = new MethodExpression("notNull");
stack.peek().addExpression(m);
stack.push(m);
} else {
stack.peek().addExpression(new TextExpression(token));
}
}
} catch (Exception e) {
e.printStackTrace();
}
ArrayList<Expression> e = root.getExpressions();
if (e.size() == 1) {
return e.get(0);
} else {
return root;
}
}
|
651333_3
|
public static Expression parse(String text) {
text = text.replaceAll("\\s*,\\s*", ",");
StringTokenizer st = new StringTokenizer(text, "$%,\'[])", true);
MethodExpression root = new MethodExpression("eval");
Stack<MethodExpression> stack = new Stack<MethodExpression>();
stack.push(root);
try {
while (st.hasMoreTokens()) {
String token = st.nextToken();
if (token.equals("%")) {
if (st.hasMoreTokens()) {
String s = st.nextToken();
s = Character.toUpperCase(s.charAt(0)) + s.substring(1);
stack.peek().addExpression(new ParameterExpression(s));
if (st.hasMoreTokens() && !st.nextToken().equals("%")) {
break;
}
}
} else if (token.equals("$")) {
if (st.hasMoreTokens()) {
String s = st.nextToken();
s = s.substring(0, s.length() - 1);
MethodExpression m = new MethodExpression(s);
stack.peek().addExpression(m);
stack.push(m);
}
} else if (token.equals(")") || token.equals("]")) {
stack.pop();
} else if (token.equals(",")) {
//ignore
} else if (token.equals("\'")) {
StringBuilder sb = new StringBuilder();
while (st.hasMoreTokens()) {
String str = st.nextToken();
if (str.equals("\'"))
break;
sb.append(str);
}
stack.peek().addExpression(new TextExpression(sb.toString()));
} else if (token.equals("[")) {
MethodExpression m = new MethodExpression("notNull");
stack.peek().addExpression(m);
stack.push(m);
} else {
stack.peek().addExpression(new TextExpression(token));
}
}
} catch (Exception e) {
e.printStackTrace();
}
ArrayList<Expression> e = root.getExpressions();
if (e.size() == 1) {
return e.get(0);
} else {
return root;
}
}
|
651333_4
|
public static Expression parse(String text) {
text = text.replaceAll("\\s*,\\s*", ",");
StringTokenizer st = new StringTokenizer(text, "$%,\'[])", true);
MethodExpression root = new MethodExpression("eval");
Stack<MethodExpression> stack = new Stack<MethodExpression>();
stack.push(root);
try {
while (st.hasMoreTokens()) {
String token = st.nextToken();
if (token.equals("%")) {
if (st.hasMoreTokens()) {
String s = st.nextToken();
s = Character.toUpperCase(s.charAt(0)) + s.substring(1);
stack.peek().addExpression(new ParameterExpression(s));
if (st.hasMoreTokens() && !st.nextToken().equals("%")) {
break;
}
}
} else if (token.equals("$")) {
if (st.hasMoreTokens()) {
String s = st.nextToken();
s = s.substring(0, s.length() - 1);
MethodExpression m = new MethodExpression(s);
stack.peek().addExpression(m);
stack.push(m);
}
} else if (token.equals(")") || token.equals("]")) {
stack.pop();
} else if (token.equals(",")) {
//ignore
} else if (token.equals("\'")) {
StringBuilder sb = new StringBuilder();
while (st.hasMoreTokens()) {
String str = st.nextToken();
if (str.equals("\'"))
break;
sb.append(str);
}
stack.peek().addExpression(new TextExpression(sb.toString()));
} else if (token.equals("[")) {
MethodExpression m = new MethodExpression("notNull");
stack.peek().addExpression(m);
stack.push(m);
} else {
stack.peek().addExpression(new TextExpression(token));
}
}
} catch (Exception e) {
e.printStackTrace();
}
ArrayList<Expression> e = root.getExpressions();
if (e.size() == 1) {
return e.get(0);
} else {
return root;
}
}
|
657157_0
|
@Override
public org.apache.lucene.search.Query parse(String query) throws ParseException {
String q = "";
for (int i = 0; i < query.length(); i++) {
if (query.charAt(i) == '"' && i + 1 < query.length() && !Character.isWhitespace(query.charAt(i + 1))) {
if (i > 0 && !Character.isWhitespace(query.charAt(i - 1))) {
q += '\\';
}
}
q += query.charAt(i);
}
return super.parse(q);
}
|
657157_1
|
public Lemmatizer(final DictHebMorph dict) {
this.dictHeb = dict;
}
|
657157_2
|
public void addSpecialCase(final String token) {
if (token.length() > TOKENIZATION_EXCEPTION_MAX_LENGTH)
throw new IllegalArgumentException("Special tokenization rule must be at most "
+ TOKENIZATION_EXCEPTION_MAX_LENGTH + " in length");
if (token.contains(" "))
throw new IllegalArgumentException("Special tokenization rule cannot contain spaces");
specialCases.addNode(token, dummyData);
}
|
662539_0
|
static double[][] reduceSpectralMeansToWLs(double[][] spectralMeans, int[] useIndices) {
double[][] reducedSpectralMeans = new double[useIndices.length][];
for (int i = 0; i < useIndices.length; i++) {
reducedSpectralMeans[i] = spectralMeans[useIndices[i]];
}
return reducedSpectralMeans;
}
|
662539_1
|
static double[][][] reduceCovarianceMatrixToWLs(double[][][] covarianceMatrix, int[] useIndices) {
double[][][] reducedMatrix = new double[covarianceMatrix.length][useIndices.length][useIndices.length];
for (int i = 0; i < covarianceMatrix.length; i++) {
double[][] innerCovarianceMatrix = covarianceMatrix[i];
for (int j = 0; j < useIndices.length; j++) {
double[] innerArray = innerCovarianceMatrix[useIndices[j]];
for (int k = 0; k < useIndices.length; k++) {
reducedMatrix[i][j][k] = innerArray[useIndices[k]];
}
}
}
return reducedMatrix;
}
|
662539_2
|
@Override
public Auxdata createAuxdata() throws AuxdataException {
double[][] spectralMeans = loadSpectralMeans();
double[][][] invCovarianceMatrix = loadInvCovarianceMatrix();
if (spectralMeans == null || invCovarianceMatrix == null) {
throw new AuxdataException("Could not load auxiliary data");
}
return new Auxdata(spectralMeans, invCovarianceMatrix);
}
|
662539_3
|
public double[] computeClassMemberships(double[] reflectances) throws OWTException {
final String pattern = "Number of reflectances must be %d but is %d.";
Assert.argument(reflectances.length == wavelengthCount, String.format(pattern, wavelengthCount, reflectances.length));
double[] y = new double[wavelengthCount];
double[][] yInvers = new double[wavelengthCount][wavelengthCount]; // yinv
double[] alphaChi = new double[classCount];
for (int i = 0; i < classCount; i++) {
for (int j = 0; j < wavelengthCount; j++) {
y[j] = reflectances[j] - uReflecMeans[j][i];
System.arraycopy(invCovMatrix[i][j], 0, yInvers[j], 0, wavelengthCount);
}
final Matrix yInvMatrix = new Matrix(yInvers);
final Matrix matrixB = yInvMatrix.times(new Matrix(y, y.length)); // b
double zSquare = 0;
for (int j = 0; j < wavelengthCount; j++) {
zSquare += y[j] * matrixB.getArray()[j][0];
}
double x = zSquare / 2.0; // no idea why this is needed. Even Tim doesn't have
double chiSquare = wavelengthCount / 2.0;
if (x <= (chiSquare + 1.0)) {
double gamma = computeIGFSeries(chiSquare, x);
alphaChi[i] = 1.0 - gamma;
} else {
double gamma = computeIGFContinuedFraction(chiSquare, x);
alphaChi[i] = gamma;
}
}
return alphaChi;
}
|
662539_4
|
static String getBestBandName(String reflectancesPrefix, float wavelength, Band[] bands) {
String bestBandName = null;
final double maxDistance = 10.0;
double wavelengthDist = Double.MAX_VALUE;
for (Band band : bands) {
final boolean isSpectralBand = band.getSpectralBandIndex() > -1;
if (isSpectralBand && band.getName().startsWith(reflectancesPrefix)) {
final float currentWavelengthDist = Math.abs(band.getSpectralWavelength() - wavelength);
if (currentWavelengthDist < wavelengthDist && currentWavelengthDist < maxDistance) {
wavelengthDist = currentWavelengthDist;
bestBandName = band.getName();
}
}
}
return bestBandName;
}
|
662539_5
|
static double trapz(double[] x, double[] y) {
double sum = 0.0;
for (int i = 1; i < x.length; i++) {
sum += 0.5 * (x[i] - x[i - 1]) * (y[i] + y[i - 1]);
}
return sum;
}
|
662539_6
|
static double trapz(double[] x, double[] y) {
double sum = 0.0;
for (int i = 1; i < x.length; i++) {
sum += 0.5 * (x[i] - x[i - 1]) * (y[i] + y[i - 1]);
}
return sum;
}
|
662539_7
|
@Override
public void dispose() {
if (glintProduct != null) {
glintProduct.dispose();
glintProduct = null;
}
if (l1pProduct != sourceProduct) {
l1pProduct.dispose();
l1pProduct = null;
}
super.dispose();
}
|
662539_8
|
@Override
public void dispose() {
if (glintProduct != null) {
glintProduct.dispose();
glintProduct = null;
}
if (l1pProduct != sourceProduct) {
l1pProduct.dispose();
l1pProduct = null;
}
super.dispose();
}
|
662539_9
|
@Override
public void dispose() {
if (glintProduct != null) {
glintProduct.dispose();
glintProduct = null;
}
if (l1pProduct != sourceProduct) {
l1pProduct.dispose();
l1pProduct = null;
}
super.dispose();
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.