SSDS.pm - Access and modify SSDS Metadata
use SSDS;
$ssds = new SSDS();
$ssds->ssdsServer('http://new-ssds.mbari.org:8080/');
$dpAccess = new SSDS::DataProducerAccess();
$newDP = new SSDS::DataProducer();
$name = "My new DataProducer";
$newDP->name($name);
$newDP->description("A description of a new DataProducer for testing");
$id = $dpAccess->insert($newDP);
$dps = $dpAccess->findByName($name, 'true', "name", 'false');
@attrs = ${$dps}[0]->get_attribute_names();
foreach my $obj (@{$dps}) {
foreach my $a (@attrs) {
next unless $obj->$a;
print " $a = " . $obj->$a . "\n";
}
}
$ret = $dpAccess->delete($newDP);
Will print out:
id = <an integer id>
name = My new DataProducer
description = A description of a new DataProducer for testing
The SSDS class provides a Perl interface to the SSDS metadata services provided by the SSDS Web Services. Most all of the Java interface to the SSDS metadata and service objects is implemented here. This module was written to make it easy to write external data processing scripts for SSDS data. (Please refer to the testSSDS.pl script that is included in the .zip file of this distribution for examples of using this module.)
The syntax used to dereference the return values from the Access methods
looks a little hairy, but it's really not that bad. If the method is designed
to return a single object (such as findByPK()) then the return value will
be an object which you may immediatley use to call its attributes.
If the method returns multiple objects (such as
listOutputs()) then the return value will be a reference to a list of
objects, which you must dereference with a '$' or '@' before using it.
Plenty of examples are provided in the method descriptions of this document.
The SSDS package contains these methods which are inherited by all the SSDS objects declared in the other packages.
ssdsServer() - set to base SSDS server, e.g. ``http://ssds.shore.mbari.org:8080/''
baseServlet() - set to the MetadataAccessServlet, e.g. 'access/MetadataAccessServlet?replyInHTML=false&';
baseUrl() - the concatenation of ssdsServer and baseServlet
delim() - the Delimiter to use for field separation of HTTP responses from SSDS, e.g. '|';
debug() - set it to 1 for ERROR, 2 for WARN, 3 for INFO, 0 for no output (the default).
It's a good idea to run with debug set to 2, then set it to 0 when put into production.
get_attribute_names() - Inherited from the Class::ObjectTemplate module which may need to be installed on your system.
ObjectCreator - Contains private support methods to create SSDS objects. The methods below are inherited by all the SSDS objects declared in the child packages.
#-------------------------------------------------------------------- #
Empty constructor.
Function to parse return of MetadataAccessServlet into a single (key, value) hash list.
Example:
my ($returnedObject, $oHash) = $obj->_buildHash($obj->delim, $data);
Function to parse return of MetadataAccessServlet into a list of (key, value) hashes list.
Example:
my ($returnedObject, $oHashes) = $obj->_buildHashes($obj->delim, $data);
Build and return an SSDS object given a URL to a MetadataAccessServlet call. If a second argument is given then that SSDS object will be instantiated rather than the object returned from the MetadataAccessServlet. If the types do not match a warning message will be printed.
Example:
# Request and return a Device object
my $url = $obj->baseUrl .
"className=DeviceTypeAccess&methodName=findByPK¶m1Type=Long¶m1Value=" .
$pk;
return $obj->_createSSDSobject($url);
Build and return a list of SSDS objects given a URL to a MetadataAccessServlet call. If a second argument is given then that SSDS object will be instantiated rather than the object returned from the MetadataAccessServlet. If the types do not match a warning message will be printed.
Example:
# Request and return a Deployment
my $url = $obj->baseUrl .
"className=Deployment&methodName=listChildDeployments&findBy=PK&findByType=String&findByValue=" .
$obj->id;
return $obj->_createSSDSobjects($url);
Execute an SSDS access method that does not return an object. Typically this is used for calling set()s, insert()s, update()s, and delete()s. Returns 1 if successful, 0 if a Fault is detected or any data is returned from the call - there should be no data returned by the service.
Example:
my $url = $obj->baseUrl .
"className=DeviceTypeAccess&methodName=insert¶m1Type=DeviceType¶m1Value=DeviceType";
$url .= $obj->delim() . "name=" . $dt->name() if $dt->name();
$url .= $obj->delim() . "description=" . $dt->description() if $dt->description();
$url .= $obj->delim() . "defaultDeploymentRole=" .
$dt->defaultDeploymentRole() if $dt->defaultDeploymentRole();
$url .= $obj->delim() . "displayInDeviceTypesPicklist=" .
$dt->displayInDeviceTypesPicklist() if $dt->displayInDeviceTypesPicklist();
return $obj->_execSSDSmethod($url);
Execute an SSDS access method that might return information. Typically this is used for calling an is_ method that would return ``java.lang.Boolean:true'' or ``java.lang.Boolean:false''.
Example:
my $obj = shift;
my $url = $obj->baseUrl .
"className=DataFile&methodName=isWebAccessible&findBy=PK&findByType=String&findByValue=" .
$obj->id;
my $ret = $obj->_returnSSDSinfo($url);
if ( $obj->debug == $_debugLevel{'INFO'} ) {
print "Return from URL = $ret\n";
}
if ($ret =~ /true/) {
return 1;
}
else {
return 0;
}
CommentTag - An SSDS CommentTag object
Instantiate an SSDS::CommentTag object
The following methods may be used to get or set any of the attributes of a CommentTag object (each attribute is both a setter and getter):
id tagString
Note: the get_attribute_names() method will return this list of attributes
Example:
my $commentTagAccess = new SSDS::CommentTagAccess();
my $commentTag = $commentTagAccess->findByPK(5777);
set the tagString for this CommentTag
DataContainer - An SSDS DataContainer object
Instantiate an SSDS::DataContainer object
The following methods may be used to get or set any of the attributes of a DataContainer object (each attribute is both a setter and getter):
id name description dataContainerType startDate endDate dateRange original uriString uri url contentLength mimeType numberOfRecords dodsAccessible dodsUrlString dodsUrl noNetCDF minLatitude maxLatitude minLongitude maxLongitude minDepth maxDepth person headerDescription recordDescription recordVariables dataContainerGroups keywords resources creator consumers
Note: the get_attribute_names() method will return this list of attributes
Example:
my $dataContainerAccess = new SSDS::DataContainerAccess();
my $dataContainer = $dataContainerAccess->findByPK(5777);
set the name for this DataContainer
set the description for this DataContainer
set the dataContainerType for this DataContainer
set the startDate for this DataContainer
set the endDate for this DataContainer
Returns the dateRange of type IDateRange from this DataContainer
Return 1 if DataContainer is original, otherwise returns 0.
set the original for this DataContainer
set the uriString for this DataContainer
set the contentLength for this DataContainer
set the mimeType for this DataContainer
set the numberOfRecords for this DataContainer
Return 1 if DataContainer is dodsAccessible, otherwise returns 0.
set the dodsAccessible for this DataContainer
set the dodsUrlString for this DataContainer
Return 1 if DataContainer is noNetCDF, otherwise returns 0.
set the noNetCDF for this DataContainer
set the minLatitude for this DataContainer
set the maxLatitude for this DataContainer
set the minLongitude for this DataContainer
set the maxLongitude for this DataContainer
set the minDepth for this DataContainer
set the maxDepth for this DataContainer
Returns the person of type Person from this DataContainer
set the Person object for this DataContainer
Example:
my $personAccess = new SSDS::PersonAccess();
my $person = new SSDS::Person();
# set some attributes of the Person object
$person->name($someUniqueName);
...
$personAccess->insert($person);
# Find the Person just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundPersons = $person->findByLikeName($someUniqueName);
# $foundPersons now contains an array of objects (because findByLikeName returns a collection
my $foundPerson = $$foundPersons[0];
# Insert a DataContainer
my $dataContainerAccess = new SSDS::DataContainerAccess();
my $dataContainer = new SSDS::DataContainer();
$dataContainer->name($someUniqueName);
$dataContainerAccess->insert($dataContainer);
# Find the DataContainer just inserted and set the Person
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDataContainers = $dataContainerAccess->findByName($someUniqueName);
$foundDataContainer = $$foundDataContainers[0];
$foundDataContainer->setPerson($foundPerson);
Returns the headerDescription of type HeaderDescription from this DataContainer
set the HeaderDescription object for this DataContainer
Example:
my $headerDescriptionAccess = new SSDS::HeaderDescriptionAccess();
my $headerDescription = new SSDS::HeaderDescription();
# set some attributes of the HeaderDescription object
$headerDescription->name($someUniqueName);
...
$headerDescriptionAccess->insert($headerDescription);
# Find the HeaderDescription just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundHeaderDescriptions = $headerDescription->findByLikeName($someUniqueName);
# $foundHeaderDescriptions now contains an array of objects (because findByLikeName returns a collection
my $foundHeaderDescription = $$foundHeaderDescriptions[0];
# Insert a DataContainer
my $dataContainerAccess = new SSDS::DataContainerAccess();
my $dataContainer = new SSDS::DataContainer();
$dataContainer->name($someUniqueName);
$dataContainerAccess->insert($dataContainer);
# Find the DataContainer just inserted and set the HeaderDescription
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDataContainers = $dataContainerAccess->findByName($someUniqueName);
$foundDataContainer = $$foundDataContainers[0];
$foundDataContainer->setHeaderDescription($foundHeaderDescription);
Returns the recordDescription of type RecordDescription from this DataContainer
set the RecordDescription object for this DataContainer
Example:
my $recordDescriptionAccess = new SSDS::RecordDescriptionAccess();
my $recordDescription = new SSDS::RecordDescription();
# set some attributes of the RecordDescription object
$recordDescription->name($someUniqueName);
...
$recordDescriptionAccess->insert($recordDescription);
# Find the RecordDescription just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundRecordDescriptions = $recordDescription->findByLikeName($someUniqueName);
# $foundRecordDescriptions now contains an array of objects (because findByLikeName returns a collection
my $foundRecordDescription = $$foundRecordDescriptions[0];
# Insert a DataContainer
my $dataContainerAccess = new SSDS::DataContainerAccess();
my $dataContainer = new SSDS::DataContainer();
$dataContainer->name($someUniqueName);
$dataContainerAccess->insert($dataContainer);
# Find the DataContainer just inserted and set the RecordDescription
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDataContainers = $dataContainerAccess->findByName($someUniqueName);
$foundDataContainer = $$foundDataContainers[0];
$foundDataContainer->setRecordDescription($foundRecordDescription);
Returns the recordVariables of type Collection from this DataContainer
add the RecordVariable object for this DataContainer
Example:
my $recordVariableAccess = new SSDS::RecordVariableAccess();
my $recordVariable = new SSDS::RecordVariable();
# set some attributes of the RecordVariable object
$recordVariable->name($someUniqueName);
...
$recordVariableAccess->insert($recordVariable);
# Find the RecordVariable just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundRecordVariables = $recordVariable->findByLikeName($someUniqueName);
# $foundRecordVariables now contains an array of objects (because findByLikeName returns a collection
my $foundRecordVariable = $$foundRecordVariables[0];
# Insert a DataContainer
my $dataContainerAccess = new SSDS::DataContainerAccess();
my $dataContainer = new SSDS::DataContainer();
$dataContainer->name($someUniqueName);
$dataContainerAccess->insert($dataContainer);
# Find the DataContainer just inserted and set the RecordVariable
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDataContainers = $dataContainerAccess->findByName($someUniqueName);
$foundDataContainer = $$foundDataContainers[0];
$foundDataContainer->addRecordVariable($foundRecordVariable);
Returns the dataContainerGroups of type Collection from this DataContainer
add the DataContainerGroup object for this DataContainer
Example:
my $dataContainerGroupAccess = new SSDS::DataContainerGroupAccess();
my $dataContainerGroup = new SSDS::DataContainerGroup();
# set some attributes of the DataContainerGroup object
$dataContainerGroup->name($someUniqueName);
...
$dataContainerGroupAccess->insert($dataContainerGroup);
# Find the DataContainerGroup just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundDataContainerGroups = $dataContainerGroup->findByLikeName($someUniqueName);
# $foundDataContainerGroups now contains an array of objects (because findByLikeName returns a collection
my $foundDataContainerGroup = $$foundDataContainerGroups[0];
# Insert a DataContainer
my $dataContainerAccess = new SSDS::DataContainerAccess();
my $dataContainer = new SSDS::DataContainer();
$dataContainer->name($someUniqueName);
$dataContainerAccess->insert($dataContainer);
# Find the DataContainer just inserted and set the DataContainerGroup
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDataContainers = $dataContainerAccess->findByName($someUniqueName);
$foundDataContainer = $$foundDataContainers[0];
$foundDataContainer->addDataContainerGroup($foundDataContainerGroup);
rem the RemoveDataContainerGroup object for this DataContainer
Example:
my $removeDataContainerGroupAccess = new SSDS::RemoveDataContainerGroupAccess();
my $removeDataContainerGroup = new SSDS::RemoveDataContainerGroup();
# set some attributes of the RemoveDataContainerGroup object
$removeDataContainerGroup->name($someUniqueName);
...
$removeDataContainerGroupAccess->insert($removeDataContainerGroup);
# Find the RemoveDataContainerGroup just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundRemoveDataContainerGroups = $removeDataContainerGroup->findByLikeName($someUniqueName);
# $foundRemoveDataContainerGroups now contains an array of objects (because findByLikeName returns a collection
my $foundRemoveDataContainerGroup = $$foundRemoveDataContainerGroups[0];
# Insert a DataContainer
my $dataContainerAccess = new SSDS::DataContainerAccess();
my $dataContainer = new SSDS::DataContainer();
$dataContainer->name($someUniqueName);
$dataContainerAccess->insert($dataContainer);
# Find the DataContainer just inserted and set the RemoveDataContainerGroup
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDataContainers = $dataContainerAccess->findByName($someUniqueName);
$foundDataContainer = $$foundDataContainers[0];
$foundDataContainer->removeDataContainerGroup($foundRemoveDataContainerGroup);
Returns the keywords of type Collection from this DataContainer
add the Keyword object for this DataContainer
Example:
my $keywordAccess = new SSDS::KeywordAccess();
my $keyword = new SSDS::Keyword();
# set some attributes of the Keyword object
$keyword->name($someUniqueName);
...
$keywordAccess->insert($keyword);
# Find the Keyword just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundKeywords = $keyword->findByLikeName($someUniqueName);
# $foundKeywords now contains an array of objects (because findByLikeName returns a collection
my $foundKeyword = $$foundKeywords[0];
# Insert a DataContainer
my $dataContainerAccess = new SSDS::DataContainerAccess();
my $dataContainer = new SSDS::DataContainer();
$dataContainer->name($someUniqueName);
$dataContainerAccess->insert($dataContainer);
# Find the DataContainer just inserted and set the Keyword
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDataContainers = $dataContainerAccess->findByName($someUniqueName);
$foundDataContainer = $$foundDataContainers[0];
$foundDataContainer->addKeyword($foundKeyword);
rem the RemoveKeyword object for this DataContainer
Example:
my $removeKeywordAccess = new SSDS::RemoveKeywordAccess();
my $removeKeyword = new SSDS::RemoveKeyword();
# set some attributes of the RemoveKeyword object
$removeKeyword->name($someUniqueName);
...
$removeKeywordAccess->insert($removeKeyword);
# Find the RemoveKeyword just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundRemoveKeywords = $removeKeyword->findByLikeName($someUniqueName);
# $foundRemoveKeywords now contains an array of objects (because findByLikeName returns a collection
my $foundRemoveKeyword = $$foundRemoveKeywords[0];
# Insert a DataContainer
my $dataContainerAccess = new SSDS::DataContainerAccess();
my $dataContainer = new SSDS::DataContainer();
$dataContainer->name($someUniqueName);
$dataContainerAccess->insert($dataContainer);
# Find the DataContainer just inserted and set the RemoveKeyword
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDataContainers = $dataContainerAccess->findByName($someUniqueName);
$foundDataContainer = $$foundDataContainers[0];
$foundDataContainer->removeKeyword($foundRemoveKeyword);
Returns the resources of type Collection from this DataContainer
add the Resource object for this DataContainer
Example:
my $resourceAccess = new SSDS::ResourceAccess();
my $resource = new SSDS::Resource();
# set some attributes of the Resource object
$resource->name($someUniqueName);
...
$resourceAccess->insert($resource);
# Find the Resource just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundResources = $resource->findByLikeName($someUniqueName);
# $foundResources now contains an array of objects (because findByLikeName returns a collection
my $foundResource = $$foundResources[0];
# Insert a DataContainer
my $dataContainerAccess = new SSDS::DataContainerAccess();
my $dataContainer = new SSDS::DataContainer();
$dataContainer->name($someUniqueName);
$dataContainerAccess->insert($dataContainer);
# Find the DataContainer just inserted and set the Resource
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDataContainers = $dataContainerAccess->findByName($someUniqueName);
$foundDataContainer = $$foundDataContainers[0];
$foundDataContainer->addResource($foundResource);
rem the RemoveResource object for this DataContainer
Example:
my $removeResourceAccess = new SSDS::RemoveResourceAccess();
my $removeResource = new SSDS::RemoveResource();
# set some attributes of the RemoveResource object
$removeResource->name($someUniqueName);
...
$removeResourceAccess->insert($removeResource);
# Find the RemoveResource just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundRemoveResources = $removeResource->findByLikeName($someUniqueName);
# $foundRemoveResources now contains an array of objects (because findByLikeName returns a collection
my $foundRemoveResource = $$foundRemoveResources[0];
# Insert a DataContainer
my $dataContainerAccess = new SSDS::DataContainerAccess();
my $dataContainer = new SSDS::DataContainer();
$dataContainer->name($someUniqueName);
$dataContainerAccess->insert($dataContainer);
# Find the DataContainer just inserted and set the RemoveResource
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDataContainers = $dataContainerAccess->findByName($someUniqueName);
$foundDataContainer = $$foundDataContainers[0];
$foundDataContainer->removeResource($foundRemoveResource);
Returns the creator of type DataProducer from this DataContainer
set the Creator object for this DataContainer
Example:
my $creatorAccess = new SSDS::CreatorAccess();
my $creator = new SSDS::Creator();
# set some attributes of the Creator object
$creator->name($someUniqueName);
...
$creatorAccess->insert($creator);
# Find the Creator just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundCreators = $creator->findByLikeName($someUniqueName);
# $foundCreators now contains an array of objects (because findByLikeName returns a collection
my $foundCreator = $$foundCreators[0];
# Insert a DataContainer
my $dataContainerAccess = new SSDS::DataContainerAccess();
my $dataContainer = new SSDS::DataContainer();
$dataContainer->name($someUniqueName);
$dataContainerAccess->insert($dataContainer);
# Find the DataContainer just inserted and set the Creator
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDataContainers = $dataContainerAccess->findByName($someUniqueName);
$foundDataContainer = $$foundDataContainers[0];
$foundDataContainer->setCreator($foundCreator);
add the Consumer object for this DataContainer
Example:
my $consumerAccess = new SSDS::ConsumerAccess();
my $consumer = new SSDS::Consumer();
# set some attributes of the Consumer object
$consumer->name($someUniqueName);
...
$consumerAccess->insert($consumer);
# Find the Consumer just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundConsumers = $consumer->findByLikeName($someUniqueName);
# $foundConsumers now contains an array of objects (because findByLikeName returns a collection
my $foundConsumer = $$foundConsumers[0];
# Insert a DataContainer
my $dataContainerAccess = new SSDS::DataContainerAccess();
my $dataContainer = new SSDS::DataContainer();
$dataContainer->name($someUniqueName);
$dataContainerAccess->insert($dataContainer);
# Find the DataContainer just inserted and set the Consumer
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDataContainers = $dataContainerAccess->findByName($someUniqueName);
$foundDataContainer = $$foundDataContainers[0];
$foundDataContainer->addConsumer($foundConsumer);
rem the RemoveConsumer object for this DataContainer
Example:
my $removeConsumerAccess = new SSDS::RemoveConsumerAccess();
my $removeConsumer = new SSDS::RemoveConsumer();
# set some attributes of the RemoveConsumer object
$removeConsumer->name($someUniqueName);
...
$removeConsumerAccess->insert($removeConsumer);
# Find the RemoveConsumer just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundRemoveConsumers = $removeConsumer->findByLikeName($someUniqueName);
# $foundRemoveConsumers now contains an array of objects (because findByLikeName returns a collection
my $foundRemoveConsumer = $$foundRemoveConsumers[0];
# Insert a DataContainer
my $dataContainerAccess = new SSDS::DataContainerAccess();
my $dataContainer = new SSDS::DataContainer();
$dataContainer->name($someUniqueName);
$dataContainerAccess->insert($dataContainer);
# Find the DataContainer just inserted and set the RemoveConsumer
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDataContainers = $dataContainerAccess->findByName($someUniqueName);
$foundDataContainer = $$foundDataContainers[0];
$foundDataContainer->removeConsumer($foundRemoveConsumer);
Return 1 if DataContainer is validDataContainerType, otherwise returns 0.
DataContainerGroup - An SSDS DataContainerGroup object
Instantiate an SSDS::DataContainerGroup object
The following methods may be used to get or set any of the attributes of a DataContainerGroup object (each attribute is both a setter and getter):
id name description
Note: the get_attribute_names() method will return this list of attributes
Example:
my $dataContainerGroupAccess = new SSDS::DataContainerGroupAccess();
my $dataContainerGroup = $dataContainerGroupAccess->findByPK(5777);
set the name for this DataContainerGroup
set the description for this DataContainerGroup
DataProducer - An SSDS DataProducer object
Instantiate an SSDS::DataProducer object
The following methods may be used to get or set any of the attributes of a DataProducer object (each attribute is both a setter and getter):
id name description dataProducerType startDate endDate dateRange role nominalLatitude nominalLatitudeAccuracy nominalLongitude nominalLongitudeAccuracy nominalDepth nominalDepthAccuracy nominalBenthicAltitude nominalBenthicAltitudeAccuracy xoffset yoffset zoffset orientationDescription x3DOrientationText hostName person device software parentDataProducer childDataProducers dataProducerGroups inputs outputs resources keywords events
Note: the get_attribute_names() method will return this list of attributes
Example:
my $dataProducerAccess = new SSDS::DataProducerAccess();
my $dataProducer = $dataProducerAccess->findByPK(5777);
set the name for this DataProducer
set the description for this DataProducer
set the dataProducerType for this DataProducer
Returns the startDateAsEsecs of type long from this DataProducer
Returns the endDateAsEsecs of type long from this DataProducer
set the startDate for this DataProducer
set the endDate for this DataProducer
Returns the dateRange of type IDateRange from this DataProducer
set the role for this DataProducer
set the nominalLatitude for this DataProducer
set the nominalLatitudeAccuracy for this DataProducer
set the nominalLongitude for this DataProducer
set the nominalLongitudeAccuracy for this DataProducer
set the nominalDepth for this DataProducer
set the nominalDepthAccuracy for this DataProducer
set the nominalBenthicAltitude for this DataProducer
set the nominalBenthicAltitudeAccuracy for this DataProducer
set the xoffset for this DataProducer
set the yoffset for this DataProducer
set the zoffset for this DataProducer
set the orientationDescription for this DataProducer
set the x3DOrientationText for this DataProducer
set the hostName for this DataProducer
Returns the person of type Person from this DataProducer
set the Person object for this DataProducer
Example:
my $personAccess = new SSDS::PersonAccess();
my $person = new SSDS::Person();
# set some attributes of the Person object
$person->name($someUniqueName);
...
$personAccess->insert($person);
# Find the Person just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundPersons = $person->findByLikeName($someUniqueName);
# $foundPersons now contains an array of objects (because findByLikeName returns a collection
my $foundPerson = $$foundPersons[0];
# Insert a DataProducer
my $dataProducerAccess = new SSDS::DataProducerAccess();
my $dataProducer = new SSDS::DataProducer();
$dataProducer->name($someUniqueName);
$dataProducerAccess->insert($dataProducer);
# Find the DataProducer just inserted and set the Person
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDataProducers = $dataProducerAccess->findByName($someUniqueName);
$foundDataProducer = $$foundDataProducers[0];
$foundDataProducer->setPerson($foundPerson);
Returns the device of type Device from this DataProducer
set the Device object for this DataProducer
Example:
my $deviceAccess = new SSDS::DeviceAccess();
my $device = new SSDS::Device();
# set some attributes of the Device object
$device->name($someUniqueName);
...
$deviceAccess->insert($device);
# Find the Device just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundDevices = $device->findByLikeName($someUniqueName);
# $foundDevices now contains an array of objects (because findByLikeName returns a collection
my $foundDevice = $$foundDevices[0];
# Insert a DataProducer
my $dataProducerAccess = new SSDS::DataProducerAccess();
my $dataProducer = new SSDS::DataProducer();
$dataProducer->name($someUniqueName);
$dataProducerAccess->insert($dataProducer);
# Find the DataProducer just inserted and set the Device
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDataProducers = $dataProducerAccess->findByName($someUniqueName);
$foundDataProducer = $$foundDataProducers[0];
$foundDataProducer->setDevice($foundDevice);
Returns the software of type Software from this DataProducer
set the Software object for this DataProducer
Example:
my $softwareAccess = new SSDS::SoftwareAccess();
my $software = new SSDS::Software();
# set some attributes of the Software object
$software->name($someUniqueName);
...
$softwareAccess->insert($software);
# Find the Software just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundSoftwares = $software->findByLikeName($someUniqueName);
# $foundSoftwares now contains an array of objects (because findByLikeName returns a collection
my $foundSoftware = $$foundSoftwares[0];
# Insert a DataProducer
my $dataProducerAccess = new SSDS::DataProducerAccess();
my $dataProducer = new SSDS::DataProducer();
$dataProducer->name($someUniqueName);
$dataProducerAccess->insert($dataProducer);
# Find the DataProducer just inserted and set the Software
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDataProducers = $dataProducerAccess->findByName($someUniqueName);
$foundDataProducer = $$foundDataProducers[0];
$foundDataProducer->setSoftware($foundSoftware);
Returns the parentDataProducer of type DataProducer from this DataProducer
set the ParentDataProducer object for this DataProducer
Example:
my $parentDataProducerAccess = new SSDS::ParentDataProducerAccess();
my $parentDataProducer = new SSDS::ParentDataProducer();
# set some attributes of the ParentDataProducer object
$parentDataProducer->name($someUniqueName);
...
$parentDataProducerAccess->insert($parentDataProducer);
# Find the ParentDataProducer just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundParentDataProducers = $parentDataProducer->findByLikeName($someUniqueName);
# $foundParentDataProducers now contains an array of objects (because findByLikeName returns a collection
my $foundParentDataProducer = $$foundParentDataProducers[0];
# Insert a DataProducer
my $dataProducerAccess = new SSDS::DataProducerAccess();
my $dataProducer = new SSDS::DataProducer();
$dataProducer->name($someUniqueName);
$dataProducerAccess->insert($dataProducer);
# Find the DataProducer just inserted and set the ParentDataProducer
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDataProducers = $dataProducerAccess->findByName($someUniqueName);
$foundDataProducer = $$foundDataProducers[0];
$foundDataProducer->setParentDataProducer($foundParentDataProducer);
add the ChildDataProducer object for this DataProducer
Example:
my $childDataProducerAccess = new SSDS::ChildDataProducerAccess();
my $childDataProducer = new SSDS::ChildDataProducer();
# set some attributes of the ChildDataProducer object
$childDataProducer->name($someUniqueName);
...
$childDataProducerAccess->insert($childDataProducer);
# Find the ChildDataProducer just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundChildDataProducers = $childDataProducer->findByLikeName($someUniqueName);
# $foundChildDataProducers now contains an array of objects (because findByLikeName returns a collection
my $foundChildDataProducer = $$foundChildDataProducers[0];
# Insert a DataProducer
my $dataProducerAccess = new SSDS::DataProducerAccess();
my $dataProducer = new SSDS::DataProducer();
$dataProducer->name($someUniqueName);
$dataProducerAccess->insert($dataProducer);
# Find the DataProducer just inserted and set the ChildDataProducer
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDataProducers = $dataProducerAccess->findByName($someUniqueName);
$foundDataProducer = $$foundDataProducers[0];
$foundDataProducer->addChildDataProducer($foundChildDataProducer);
rem the RemoveChildDataProducer object for this DataProducer
Example:
my $removeChildDataProducerAccess = new SSDS::RemoveChildDataProducerAccess();
my $removeChildDataProducer = new SSDS::RemoveChildDataProducer();
# set some attributes of the RemoveChildDataProducer object
$removeChildDataProducer->name($someUniqueName);
...
$removeChildDataProducerAccess->insert($removeChildDataProducer);
# Find the RemoveChildDataProducer just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundRemoveChildDataProducers = $removeChildDataProducer->findByLikeName($someUniqueName);
# $foundRemoveChildDataProducers now contains an array of objects (because findByLikeName returns a collection
my $foundRemoveChildDataProducer = $$foundRemoveChildDataProducers[0];
# Insert a DataProducer
my $dataProducerAccess = new SSDS::DataProducerAccess();
my $dataProducer = new SSDS::DataProducer();
$dataProducer->name($someUniqueName);
$dataProducerAccess->insert($dataProducer);
# Find the DataProducer just inserted and set the RemoveChildDataProducer
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDataProducers = $dataProducerAccess->findByName($someUniqueName);
$foundDataProducer = $$foundDataProducers[0];
$foundDataProducer->removeChildDataProducer($foundRemoveChildDataProducer);
Returns the dataProducerGroups of type Collection from this DataProducer
add the DataProducerGroup object for this DataProducer
Example:
my $dataProducerGroupAccess = new SSDS::DataProducerGroupAccess();
my $dataProducerGroup = new SSDS::DataProducerGroup();
# set some attributes of the DataProducerGroup object
$dataProducerGroup->name($someUniqueName);
...
$dataProducerGroupAccess->insert($dataProducerGroup);
# Find the DataProducerGroup just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundDataProducerGroups = $dataProducerGroup->findByLikeName($someUniqueName);
# $foundDataProducerGroups now contains an array of objects (because findByLikeName returns a collection
my $foundDataProducerGroup = $$foundDataProducerGroups[0];
# Insert a DataProducer
my $dataProducerAccess = new SSDS::DataProducerAccess();
my $dataProducer = new SSDS::DataProducer();
$dataProducer->name($someUniqueName);
$dataProducerAccess->insert($dataProducer);
# Find the DataProducer just inserted and set the DataProducerGroup
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDataProducers = $dataProducerAccess->findByName($someUniqueName);
$foundDataProducer = $$foundDataProducers[0];
$foundDataProducer->addDataProducerGroup($foundDataProducerGroup);
rem the RemoveDataProducerGroup object for this DataProducer
Example:
my $removeDataProducerGroupAccess = new SSDS::RemoveDataProducerGroupAccess();
my $removeDataProducerGroup = new SSDS::RemoveDataProducerGroup();
# set some attributes of the RemoveDataProducerGroup object
$removeDataProducerGroup->name($someUniqueName);
...
$removeDataProducerGroupAccess->insert($removeDataProducerGroup);
# Find the RemoveDataProducerGroup just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundRemoveDataProducerGroups = $removeDataProducerGroup->findByLikeName($someUniqueName);
# $foundRemoveDataProducerGroups now contains an array of objects (because findByLikeName returns a collection
my $foundRemoveDataProducerGroup = $$foundRemoveDataProducerGroups[0];
# Insert a DataProducer
my $dataProducerAccess = new SSDS::DataProducerAccess();
my $dataProducer = new SSDS::DataProducer();
$dataProducer->name($someUniqueName);
$dataProducerAccess->insert($dataProducer);
# Find the DataProducer just inserted and set the RemoveDataProducerGroup
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDataProducers = $dataProducerAccess->findByName($someUniqueName);
$foundDataProducer = $$foundDataProducers[0];
$foundDataProducer->removeDataProducerGroup($foundRemoveDataProducerGroup);
add the Input object for this DataProducer
Example:
my $inputAccess = new SSDS::InputAccess();
my $input = new SSDS::Input();
# set some attributes of the Input object
$input->name($someUniqueName);
...
$inputAccess->insert($input);
# Find the Input just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundInputs = $input->findByLikeName($someUniqueName);
# $foundInputs now contains an array of objects (because findByLikeName returns a collection
my $foundInput = $$foundInputs[0];
# Insert a DataProducer
my $dataProducerAccess = new SSDS::DataProducerAccess();
my $dataProducer = new SSDS::DataProducer();
$dataProducer->name($someUniqueName);
$dataProducerAccess->insert($dataProducer);
# Find the DataProducer just inserted and set the Input
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDataProducers = $dataProducerAccess->findByName($someUniqueName);
$foundDataProducer = $$foundDataProducers[0];
$foundDataProducer->addInput($foundInput);
rem the RemoveInput object for this DataProducer
Example:
my $removeInputAccess = new SSDS::RemoveInputAccess();
my $removeInput = new SSDS::RemoveInput();
# set some attributes of the RemoveInput object
$removeInput->name($someUniqueName);
...
$removeInputAccess->insert($removeInput);
# Find the RemoveInput just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundRemoveInputs = $removeInput->findByLikeName($someUniqueName);
# $foundRemoveInputs now contains an array of objects (because findByLikeName returns a collection
my $foundRemoveInput = $$foundRemoveInputs[0];
# Insert a DataProducer
my $dataProducerAccess = new SSDS::DataProducerAccess();
my $dataProducer = new SSDS::DataProducer();
$dataProducer->name($someUniqueName);
$dataProducerAccess->insert($dataProducer);
# Find the DataProducer just inserted and set the RemoveInput
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDataProducers = $dataProducerAccess->findByName($someUniqueName);
$foundDataProducer = $$foundDataProducers[0];
$foundDataProducer->removeInput($foundRemoveInput);
add the Output object for this DataProducer
Example:
my $outputAccess = new SSDS::OutputAccess();
my $output = new SSDS::Output();
# set some attributes of the Output object
$output->name($someUniqueName);
...
$outputAccess->insert($output);
# Find the Output just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundOutputs = $output->findByLikeName($someUniqueName);
# $foundOutputs now contains an array of objects (because findByLikeName returns a collection
my $foundOutput = $$foundOutputs[0];
# Insert a DataProducer
my $dataProducerAccess = new SSDS::DataProducerAccess();
my $dataProducer = new SSDS::DataProducer();
$dataProducer->name($someUniqueName);
$dataProducerAccess->insert($dataProducer);
# Find the DataProducer just inserted and set the Output
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDataProducers = $dataProducerAccess->findByName($someUniqueName);
$foundDataProducer = $$foundDataProducers[0];
$foundDataProducer->addOutput($foundOutput);
rem the RemoveOutput object for this DataProducer
Example:
my $removeOutputAccess = new SSDS::RemoveOutputAccess();
my $removeOutput = new SSDS::RemoveOutput();
# set some attributes of the RemoveOutput object
$removeOutput->name($someUniqueName);
...
$removeOutputAccess->insert($removeOutput);
# Find the RemoveOutput just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundRemoveOutputs = $removeOutput->findByLikeName($someUniqueName);
# $foundRemoveOutputs now contains an array of objects (because findByLikeName returns a collection
my $foundRemoveOutput = $$foundRemoveOutputs[0];
# Insert a DataProducer
my $dataProducerAccess = new SSDS::DataProducerAccess();
my $dataProducer = new SSDS::DataProducer();
$dataProducer->name($someUniqueName);
$dataProducerAccess->insert($dataProducer);
# Find the DataProducer just inserted and set the RemoveOutput
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDataProducers = $dataProducerAccess->findByName($someUniqueName);
$foundDataProducer = $$foundDataProducers[0];
$foundDataProducer->removeOutput($foundRemoveOutput);
Returns the resources of type Collection from this DataProducer
add the Resource object for this DataProducer
Example:
my $resourceAccess = new SSDS::ResourceAccess();
my $resource = new SSDS::Resource();
# set some attributes of the Resource object
$resource->name($someUniqueName);
...
$resourceAccess->insert($resource);
# Find the Resource just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundResources = $resource->findByLikeName($someUniqueName);
# $foundResources now contains an array of objects (because findByLikeName returns a collection
my $foundResource = $$foundResources[0];
# Insert a DataProducer
my $dataProducerAccess = new SSDS::DataProducerAccess();
my $dataProducer = new SSDS::DataProducer();
$dataProducer->name($someUniqueName);
$dataProducerAccess->insert($dataProducer);
# Find the DataProducer just inserted and set the Resource
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDataProducers = $dataProducerAccess->findByName($someUniqueName);
$foundDataProducer = $$foundDataProducers[0];
$foundDataProducer->addResource($foundResource);
rem the RemoveResource object for this DataProducer
Example:
my $removeResourceAccess = new SSDS::RemoveResourceAccess();
my $removeResource = new SSDS::RemoveResource();
# set some attributes of the RemoveResource object
$removeResource->name($someUniqueName);
...
$removeResourceAccess->insert($removeResource);
# Find the RemoveResource just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundRemoveResources = $removeResource->findByLikeName($someUniqueName);
# $foundRemoveResources now contains an array of objects (because findByLikeName returns a collection
my $foundRemoveResource = $$foundRemoveResources[0];
# Insert a DataProducer
my $dataProducerAccess = new SSDS::DataProducerAccess();
my $dataProducer = new SSDS::DataProducer();
$dataProducer->name($someUniqueName);
$dataProducerAccess->insert($dataProducer);
# Find the DataProducer just inserted and set the RemoveResource
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDataProducers = $dataProducerAccess->findByName($someUniqueName);
$foundDataProducer = $$foundDataProducers[0];
$foundDataProducer->removeResource($foundRemoveResource);
Returns the keywords of type Collection from this DataProducer
add the Keyword object for this DataProducer
Example:
my $keywordAccess = new SSDS::KeywordAccess();
my $keyword = new SSDS::Keyword();
# set some attributes of the Keyword object
$keyword->name($someUniqueName);
...
$keywordAccess->insert($keyword);
# Find the Keyword just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundKeywords = $keyword->findByLikeName($someUniqueName);
# $foundKeywords now contains an array of objects (because findByLikeName returns a collection
my $foundKeyword = $$foundKeywords[0];
# Insert a DataProducer
my $dataProducerAccess = new SSDS::DataProducerAccess();
my $dataProducer = new SSDS::DataProducer();
$dataProducer->name($someUniqueName);
$dataProducerAccess->insert($dataProducer);
# Find the DataProducer just inserted and set the Keyword
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDataProducers = $dataProducerAccess->findByName($someUniqueName);
$foundDataProducer = $$foundDataProducers[0];
$foundDataProducer->addKeyword($foundKeyword);
rem the RemoveKeyword object for this DataProducer
Example:
my $removeKeywordAccess = new SSDS::RemoveKeywordAccess();
my $removeKeyword = new SSDS::RemoveKeyword();
# set some attributes of the RemoveKeyword object
$removeKeyword->name($someUniqueName);
...
$removeKeywordAccess->insert($removeKeyword);
# Find the RemoveKeyword just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundRemoveKeywords = $removeKeyword->findByLikeName($someUniqueName);
# $foundRemoveKeywords now contains an array of objects (because findByLikeName returns a collection
my $foundRemoveKeyword = $$foundRemoveKeywords[0];
# Insert a DataProducer
my $dataProducerAccess = new SSDS::DataProducerAccess();
my $dataProducer = new SSDS::DataProducer();
$dataProducer->name($someUniqueName);
$dataProducerAccess->insert($dataProducer);
# Find the DataProducer just inserted and set the RemoveKeyword
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDataProducers = $dataProducerAccess->findByName($someUniqueName);
$foundDataProducer = $$foundDataProducers[0];
$foundDataProducer->removeKeyword($foundRemoveKeyword);
Returns the events of type Collection from this DataProducer
add the Event object for this DataProducer
Example:
my $eventAccess = new SSDS::EventAccess();
my $event = new SSDS::Event();
# set some attributes of the Event object
$event->name($someUniqueName);
...
$eventAccess->insert($event);
# Find the Event just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundEvents = $event->findByLikeName($someUniqueName);
# $foundEvents now contains an array of objects (because findByLikeName returns a collection
my $foundEvent = $$foundEvents[0];
# Insert a DataProducer
my $dataProducerAccess = new SSDS::DataProducerAccess();
my $dataProducer = new SSDS::DataProducer();
$dataProducer->name($someUniqueName);
$dataProducerAccess->insert($dataProducer);
# Find the DataProducer just inserted and set the Event
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDataProducers = $dataProducerAccess->findByName($someUniqueName);
$foundDataProducer = $$foundDataProducers[0];
$foundDataProducer->addEvent($foundEvent);
rem the RemoveEvent object for this DataProducer
Example:
my $removeEventAccess = new SSDS::RemoveEventAccess();
my $removeEvent = new SSDS::RemoveEvent();
# set some attributes of the RemoveEvent object
$removeEvent->name($someUniqueName);
...
$removeEventAccess->insert($removeEvent);
# Find the RemoveEvent just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundRemoveEvents = $removeEvent->findByLikeName($someUniqueName);
# $foundRemoveEvents now contains an array of objects (because findByLikeName returns a collection
my $foundRemoveEvent = $$foundRemoveEvents[0];
# Insert a DataProducer
my $dataProducerAccess = new SSDS::DataProducerAccess();
my $dataProducer = new SSDS::DataProducer();
$dataProducer->name($someUniqueName);
$dataProducerAccess->insert($dataProducer);
# Find the DataProducer just inserted and set the RemoveEvent
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDataProducers = $dataProducerAccess->findByName($someUniqueName);
$foundDataProducer = $$foundDataProducers[0];
$foundDataProducer->removeEvent($foundRemoveEvent);
Return 1 if DataProducer is validDataProducerType, otherwise returns 0.
Return 1 if DataProducer is validRole, otherwise returns 0.
DataProducerGroup - An SSDS DataProducerGroup object
Instantiate an SSDS::DataProducerGroup object
The following methods may be used to get or set any of the attributes of a DataProducerGroup object (each attribute is both a setter and getter):
id name description
Note: the get_attribute_names() method will return this list of attributes
Example:
my $dataProducerGroupAccess = new SSDS::DataProducerGroupAccess();
my $dataProducerGroup = $dataProducerGroupAccess->findByPK(5777);
set the name for this DataProducerGroup
set the description for this DataProducerGroup
DateRange - An SSDS DateRange object
Instantiate an SSDS::DateRange object
The following methods may be used to get or set any of the attributes of a DateRange object (each attribute is both a setter and getter):
startDate endDate dateRange
Note: the get_attribute_names() method will return this list of attributes
Example:
my $dateRangeAccess = new SSDS::DateRangeAccess();
my $dateRange = $dateRangeAccess->findByPK(5777);
set the startDate for this DateRange
set the endDate for this DateRange
Returns the dateRange of type IDateRange from this DateRange
set the DateRange object for this DateRange
Example:
my $dateRangeAccess = new SSDS::DateRangeAccess();
my $dateRange = new SSDS::DateRange();
# set some attributes of the DateRange object
$dateRange->name($someUniqueName);
...
$dateRangeAccess->insert($dateRange);
# Find the DateRange just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundDateRanges = $dateRange->findByLikeName($someUniqueName);
# $foundDateRanges now contains an array of objects (because findByLikeName returns a collection
my $foundDateRange = $$foundDateRanges[0];
# Insert a DateRange
my $dateRangeAccess = new SSDS::DateRangeAccess();
my $dateRange = new SSDS::DateRange();
$dateRange->name($someUniqueName);
$dateRangeAccess->insert($dateRange);
# Find the DateRange just inserted and set the DateRange
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDateRanges = $dateRangeAccess->findByName($someUniqueName);
$foundDateRange = $$foundDateRanges[0];
$foundDateRange->setDateRange($foundDateRange);
Device - An SSDS Device object
Instantiate an SSDS::Device object
The following methods may be used to get or set any of the attributes of a Device object (each attribute is both a setter and getter):
id uuid uuidAsBytes name description mfgName mfgModel mfgSerialNumber infoUrlList person deviceType resources
Note: the get_attribute_names() method will return this list of attributes
Example:
my $deviceAccess = new SSDS::DeviceAccess();
my $device = $deviceAccess->findByPK(5777);
set the uuid for this Device
set the name for this Device
set the description for this Device
set the mfgName for this Device
set the mfgModel for this Device
set the mfgSerialNumber for this Device
set the infoUrlList for this Device
Returns the person of type Person from this Device
set the Person object for this Device
Example:
my $personAccess = new SSDS::PersonAccess();
my $person = new SSDS::Person();
# set some attributes of the Person object
$person->name($someUniqueName);
...
$personAccess->insert($person);
# Find the Person just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundPersons = $person->findByLikeName($someUniqueName);
# $foundPersons now contains an array of objects (because findByLikeName returns a collection
my $foundPerson = $$foundPersons[0];
# Insert a Device
my $deviceAccess = new SSDS::DeviceAccess();
my $device = new SSDS::Device();
$device->name($someUniqueName);
$deviceAccess->insert($device);
# Find the Device just inserted and set the Person
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDevices = $deviceAccess->findByName($someUniqueName);
$foundDevice = $$foundDevices[0];
$foundDevice->setPerson($foundPerson);
Returns the deviceType of type DeviceType from this Device
set the DeviceType object for this Device
Example:
my $deviceTypeAccess = new SSDS::DeviceTypeAccess();
my $deviceType = new SSDS::DeviceType();
# set some attributes of the DeviceType object
$deviceType->name($someUniqueName);
...
$deviceTypeAccess->insert($deviceType);
# Find the DeviceType just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundDeviceTypes = $deviceType->findByLikeName($someUniqueName);
# $foundDeviceTypes now contains an array of objects (because findByLikeName returns a collection
my $foundDeviceType = $$foundDeviceTypes[0];
# Insert a Device
my $deviceAccess = new SSDS::DeviceAccess();
my $device = new SSDS::Device();
$device->name($someUniqueName);
$deviceAccess->insert($device);
# Find the Device just inserted and set the DeviceType
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDevices = $deviceAccess->findByName($someUniqueName);
$foundDevice = $$foundDevices[0];
$foundDevice->setDeviceType($foundDeviceType);
Returns the resources of type Collection from this Device
add the Resource object for this Device
Example:
my $resourceAccess = new SSDS::ResourceAccess();
my $resource = new SSDS::Resource();
# set some attributes of the Resource object
$resource->name($someUniqueName);
...
$resourceAccess->insert($resource);
# Find the Resource just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundResources = $resource->findByLikeName($someUniqueName);
# $foundResources now contains an array of objects (because findByLikeName returns a collection
my $foundResource = $$foundResources[0];
# Insert a Device
my $deviceAccess = new SSDS::DeviceAccess();
my $device = new SSDS::Device();
$device->name($someUniqueName);
$deviceAccess->insert($device);
# Find the Device just inserted and set the Resource
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDevices = $deviceAccess->findByName($someUniqueName);
$foundDevice = $$foundDevices[0];
$foundDevice->addResource($foundResource);
rem the RemoveResource object for this Device
Example:
my $removeResourceAccess = new SSDS::RemoveResourceAccess();
my $removeResource = new SSDS::RemoveResource();
# set some attributes of the RemoveResource object
$removeResource->name($someUniqueName);
...
$removeResourceAccess->insert($removeResource);
# Find the RemoveResource just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundRemoveResources = $removeResource->findByLikeName($someUniqueName);
# $foundRemoveResources now contains an array of objects (because findByLikeName returns a collection
my $foundRemoveResource = $$foundRemoveResources[0];
# Insert a Device
my $deviceAccess = new SSDS::DeviceAccess();
my $device = new SSDS::Device();
$device->name($someUniqueName);
$deviceAccess->insert($device);
# Find the Device just inserted and set the RemoveResource
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundDevices = $deviceAccess->findByName($someUniqueName);
$foundDevice = $$foundDevices[0];
$foundDevice->removeResource($foundRemoveResource);
DeviceType - An SSDS DeviceType object
Instantiate an SSDS::DeviceType object
The following methods may be used to get or set any of the attributes of a DeviceType object (each attribute is both a setter and getter):
id name description
Note: the get_attribute_names() method will return this list of attributes
Example:
my $deviceTypeAccess = new SSDS::DeviceTypeAccess();
my $deviceType = $deviceTypeAccess->findByPK(5777);
set the name for this DeviceType
set the description for this DeviceType
Event - An SSDS Event object
Instantiate an SSDS::Event object
The following methods may be used to get or set any of the attributes of a Event object (each attribute is both a setter and getter):
id name description startDate endDate dateRange
Note: the get_attribute_names() method will return this list of attributes
Example:
my $eventAccess = new SSDS::EventAccess();
my $event = $eventAccess->findByPK(5777);
set the name for this Event
set the description for this Event
set the startDate for this Event
set the endDate for this Event
Returns the dateRange of type IDateRange from this Event
HeaderDescription - An SSDS HeaderDescription object
Instantiate an SSDS::HeaderDescription object
The following methods may be used to get or set any of the attributes of a HeaderDescription object (each attribute is both a setter and getter):
id description byteOffset numHeaderLines commentTags commentTagsAsStrings
Note: the get_attribute_names() method will return this list of attributes
Example:
my $headerDescriptionAccess = new SSDS::HeaderDescriptionAccess();
my $headerDescription = $headerDescriptionAccess->findByPK(5777);
set the description for this HeaderDescription
set the byteOffset for this HeaderDescription
set the numHeaderLines for this HeaderDescription
Returns the commentTags of type Collection from this HeaderDescription
add the CommentTag object for this HeaderDescription
Example:
my $commentTagAccess = new SSDS::CommentTagAccess();
my $commentTag = new SSDS::CommentTag();
# set some attributes of the CommentTag object
$commentTag->name($someUniqueName);
...
$commentTagAccess->insert($commentTag);
# Find the CommentTag just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundCommentTags = $commentTag->findByLikeName($someUniqueName);
# $foundCommentTags now contains an array of objects (because findByLikeName returns a collection
my $foundCommentTag = $$foundCommentTags[0];
# Insert a HeaderDescription
my $headerDescriptionAccess = new SSDS::HeaderDescriptionAccess();
my $headerDescription = new SSDS::HeaderDescription();
$headerDescription->name($someUniqueName);
$headerDescriptionAccess->insert($headerDescription);
# Find the HeaderDescription just inserted and set the CommentTag
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundHeaderDescriptions = $headerDescriptionAccess->findByName($someUniqueName);
$foundHeaderDescription = $$foundHeaderDescriptions[0];
$foundHeaderDescription->addCommentTag($foundCommentTag);
rem the RemoveCommentTag object for this HeaderDescription
Example:
my $removeCommentTagAccess = new SSDS::RemoveCommentTagAccess();
my $removeCommentTag = new SSDS::RemoveCommentTag();
# set some attributes of the RemoveCommentTag object
$removeCommentTag->name($someUniqueName);
...
$removeCommentTagAccess->insert($removeCommentTag);
# Find the RemoveCommentTag just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundRemoveCommentTags = $removeCommentTag->findByLikeName($someUniqueName);
# $foundRemoveCommentTags now contains an array of objects (because findByLikeName returns a collection
my $foundRemoveCommentTag = $$foundRemoveCommentTags[0];
# Insert a HeaderDescription
my $headerDescriptionAccess = new SSDS::HeaderDescriptionAccess();
my $headerDescription = new SSDS::HeaderDescription();
$headerDescription->name($someUniqueName);
$headerDescriptionAccess->insert($headerDescription);
# Find the HeaderDescription just inserted and set the RemoveCommentTag
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundHeaderDescriptions = $headerDescriptionAccess->findByName($someUniqueName);
$foundHeaderDescription = $$foundHeaderDescriptions[0];
$foundHeaderDescription->removeCommentTag($foundRemoveCommentTag);
Keyword - An SSDS Keyword object
Instantiate an SSDS::Keyword object
The following methods may be used to get or set any of the attributes of a Keyword object (each attribute is both a setter and getter):
id name description
Note: the get_attribute_names() method will return this list of attributes
Example:
my $keywordAccess = new SSDS::KeywordAccess();
my $keyword = $keywordAccess->findByPK(5777);
set the name for this Keyword
set the description for this Keyword
Person - An SSDS Person object
Instantiate an SSDS::Person object
The following methods may be used to get or set any of the attributes of a Person object (each attribute is both a setter and getter):
id firstname surname organization username password email phone address1 address2 city state zipcode status userGroups
Note: the get_attribute_names() method will return this list of attributes
Example:
my $personAccess = new SSDS::PersonAccess();
my $person = $personAccess->findByPK(5777);
set the firstname for this Person
set the surname for this Person
set the organization for this Person
set the username for this Person
set the password for this Person
set the email for this Person
set the phone for this Person
set the address1 for this Person
set the address2 for this Person
set the city for this Person
set the state for this Person
set the zipcode for this Person
set the status for this Person
Return 1 if Person is validStatus, otherwise returns 0.
Returns the userGroups of type Collection from this Person
add the UserGroup object for this Person
Example:
my $userGroupAccess = new SSDS::UserGroupAccess();
my $userGroup = new SSDS::UserGroup();
# set some attributes of the UserGroup object
$userGroup->name($someUniqueName);
...
$userGroupAccess->insert($userGroup);
# Find the UserGroup just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundUserGroups = $userGroup->findByLikeName($someUniqueName);
# $foundUserGroups now contains an array of objects (because findByLikeName returns a collection
my $foundUserGroup = $$foundUserGroups[0];
# Insert a Person
my $personAccess = new SSDS::PersonAccess();
my $person = new SSDS::Person();
$person->name($someUniqueName);
$personAccess->insert($person);
# Find the Person just inserted and set the UserGroup
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundPersons = $personAccess->findByName($someUniqueName);
$foundPerson = $$foundPersons[0];
$foundPerson->addUserGroup($foundUserGroup);
rem the RemoveUserGroup object for this Person
Example:
my $removeUserGroupAccess = new SSDS::RemoveUserGroupAccess();
my $removeUserGroup = new SSDS::RemoveUserGroup();
# set some attributes of the RemoveUserGroup object
$removeUserGroup->name($someUniqueName);
...
$removeUserGroupAccess->insert($removeUserGroup);
# Find the RemoveUserGroup just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundRemoveUserGroups = $removeUserGroup->findByLikeName($someUniqueName);
# $foundRemoveUserGroups now contains an array of objects (because findByLikeName returns a collection
my $foundRemoveUserGroup = $$foundRemoveUserGroups[0];
# Insert a Person
my $personAccess = new SSDS::PersonAccess();
my $person = new SSDS::Person();
$person->name($someUniqueName);
$personAccess->insert($person);
# Find the Person just inserted and set the RemoveUserGroup
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundPersons = $personAccess->findByName($someUniqueName);
$foundPerson = $$foundPersons[0];
$foundPerson->removeUserGroup($foundRemoveUserGroup);
RecordDescription - An SSDS RecordDescription object
Instantiate an SSDS::RecordDescription object
The following methods may be used to get or set any of the attributes of a RecordDescription object (each attribute is both a setter and getter):
id recordType bufferStyle bufferParseType bufferItemSeparator bufferLengthType recordTerminator parseable endian recordParseRegExp recordVariables
Note: the get_attribute_names() method will return this list of attributes
Example:
my $recordDescriptionAccess = new SSDS::RecordDescriptionAccess();
my $recordDescription = $recordDescriptionAccess->findByPK(5777);
set the recordType for this RecordDescription
set the bufferStyle for this RecordDescription
set the bufferParseType for this RecordDescription
set the bufferItemSeparator for this RecordDescription
set the bufferLengthType for this RecordDescription
set the recordTerminator for this RecordDescription
Return 1 if RecordDescription is parseable, otherwise returns 0.
set the parseable for this RecordDescription
set the endian for this RecordDescription
set the recordParseRegExp for this RecordDescription
Returns the recordVariables of type Collection from this RecordDescription
add the RecordVariable object for this RecordDescription
Example:
my $recordVariableAccess = new SSDS::RecordVariableAccess();
my $recordVariable = new SSDS::RecordVariable();
# set some attributes of the RecordVariable object
$recordVariable->name($someUniqueName);
...
$recordVariableAccess->insert($recordVariable);
# Find the RecordVariable just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundRecordVariables = $recordVariable->findByLikeName($someUniqueName);
# $foundRecordVariables now contains an array of objects (because findByLikeName returns a collection
my $foundRecordVariable = $$foundRecordVariables[0];
# Insert a RecordDescription
my $recordDescriptionAccess = new SSDS::RecordDescriptionAccess();
my $recordDescription = new SSDS::RecordDescription();
$recordDescription->name($someUniqueName);
$recordDescriptionAccess->insert($recordDescription);
# Find the RecordDescription just inserted and set the RecordVariable
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundRecordDescriptions = $recordDescriptionAccess->findByName($someUniqueName);
$foundRecordDescription = $$foundRecordDescriptions[0];
$foundRecordDescription->addRecordVariable($foundRecordVariable);
rem the RemoveRecordVariable object for this RecordDescription
Example:
my $removeRecordVariableAccess = new SSDS::RemoveRecordVariableAccess();
my $removeRecordVariable = new SSDS::RemoveRecordVariable();
# set some attributes of the RemoveRecordVariable object
$removeRecordVariable->name($someUniqueName);
...
$removeRecordVariableAccess->insert($removeRecordVariable);
# Find the RemoveRecordVariable just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundRemoveRecordVariables = $removeRecordVariable->findByLikeName($someUniqueName);
# $foundRemoveRecordVariables now contains an array of objects (because findByLikeName returns a collection
my $foundRemoveRecordVariable = $$foundRemoveRecordVariables[0];
# Insert a RecordDescription
my $recordDescriptionAccess = new SSDS::RecordDescriptionAccess();
my $recordDescription = new SSDS::RecordDescription();
$recordDescription->name($someUniqueName);
$recordDescriptionAccess->insert($recordDescription);
# Find the RecordDescription just inserted and set the RemoveRecordVariable
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundRecordDescriptions = $recordDescriptionAccess->findByName($someUniqueName);
$foundRecordDescription = $$foundRecordDescriptions[0];
$foundRecordDescription->removeRecordVariable($foundRemoveRecordVariable);
Return 1 if RecordDescription is validBufferStyle, otherwise returns 0.
Return 1 if RecordDescription is validBufferLengthType, otherwise returns 0.
Return 1 if RecordDescription is validEndian, otherwise returns 0.
Return 1 if RecordDescription is validParseType, otherwise returns 0.
RecordVariable - An SSDS RecordVariable object
Instantiate an SSDS::RecordVariable object
The following methods may be used to get or set any of the attributes of a RecordVariable object (each attribute is both a setter and getter):
id name description longName format units columnIndex validMin validMax missingValue accuracy displayMin displayMax referenceScale conversionScale conversionOffset convertedUnits sourceSensorID parseRegExp standardVariable standardUnit standardReferenceScale standardDomain standardKeyword
Note: the get_attribute_names() method will return this list of attributes
Example:
my $recordVariableAccess = new SSDS::RecordVariableAccess();
my $recordVariable = $recordVariableAccess->findByPK(5777);
set the name for this RecordVariable
set the description for this RecordVariable
set the longName for this RecordVariable
set the format for this RecordVariable
set the units for this RecordVariable
set the columnIndex for this RecordVariable
set the validMin for this RecordVariable
set the validMax for this RecordVariable
set the missingValue for this RecordVariable
set the accuracy for this RecordVariable
set the displayMin for this RecordVariable
set the displayMax for this RecordVariable
set the referenceScale for this RecordVariable
set the conversionScale for this RecordVariable
set the conversionOffset for this RecordVariable
set the convertedUnits for this RecordVariable
set the sourceSensorID for this RecordVariable
set the parseRegExp for this RecordVariable
Returns the standardVariable of type StandardVariable from this RecordVariable
set the StandardVariable object for this RecordVariable
Example:
my $standardVariableAccess = new SSDS::StandardVariableAccess();
my $standardVariable = new SSDS::StandardVariable();
# set some attributes of the StandardVariable object
$standardVariable->name($someUniqueName);
...
$standardVariableAccess->insert($standardVariable);
# Find the StandardVariable just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundStandardVariables = $standardVariable->findByLikeName($someUniqueName);
# $foundStandardVariables now contains an array of objects (because findByLikeName returns a collection
my $foundStandardVariable = $$foundStandardVariables[0];
# Insert a RecordVariable
my $recordVariableAccess = new SSDS::RecordVariableAccess();
my $recordVariable = new SSDS::RecordVariable();
$recordVariable->name($someUniqueName);
$recordVariableAccess->insert($recordVariable);
# Find the RecordVariable just inserted and set the StandardVariable
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundRecordVariables = $recordVariableAccess->findByName($someUniqueName);
$foundRecordVariable = $$foundRecordVariables[0];
$foundRecordVariable->setStandardVariable($foundStandardVariable);
Returns the standardUnit of type StandardUnit from this RecordVariable
set the StandardUnit object for this RecordVariable
Example:
my $standardUnitAccess = new SSDS::StandardUnitAccess();
my $standardUnit = new SSDS::StandardUnit();
# set some attributes of the StandardUnit object
$standardUnit->name($someUniqueName);
...
$standardUnitAccess->insert($standardUnit);
# Find the StandardUnit just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundStandardUnits = $standardUnit->findByLikeName($someUniqueName);
# $foundStandardUnits now contains an array of objects (because findByLikeName returns a collection
my $foundStandardUnit = $$foundStandardUnits[0];
# Insert a RecordVariable
my $recordVariableAccess = new SSDS::RecordVariableAccess();
my $recordVariable = new SSDS::RecordVariable();
$recordVariable->name($someUniqueName);
$recordVariableAccess->insert($recordVariable);
# Find the RecordVariable just inserted and set the StandardUnit
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundRecordVariables = $recordVariableAccess->findByName($someUniqueName);
$foundRecordVariable = $$foundRecordVariables[0];
$foundRecordVariable->setStandardUnit($foundStandardUnit);
Returns the standardReferenceScale of type StandardReferenceScale from this RecordVariable
set the StandardReferenceScale object for this RecordVariable
Example:
my $standardReferenceScaleAccess = new SSDS::StandardReferenceScaleAccess();
my $standardReferenceScale = new SSDS::StandardReferenceScale();
# set some attributes of the StandardReferenceScale object
$standardReferenceScale->name($someUniqueName);
...
$standardReferenceScaleAccess->insert($standardReferenceScale);
# Find the StandardReferenceScale just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundStandardReferenceScales = $standardReferenceScale->findByLikeName($someUniqueName);
# $foundStandardReferenceScales now contains an array of objects (because findByLikeName returns a collection
my $foundStandardReferenceScale = $$foundStandardReferenceScales[0];
# Insert a RecordVariable
my $recordVariableAccess = new SSDS::RecordVariableAccess();
my $recordVariable = new SSDS::RecordVariable();
$recordVariable->name($someUniqueName);
$recordVariableAccess->insert($recordVariable);
# Find the RecordVariable just inserted and set the StandardReferenceScale
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundRecordVariables = $recordVariableAccess->findByName($someUniqueName);
$foundRecordVariable = $$foundRecordVariables[0];
$foundRecordVariable->setStandardReferenceScale($foundStandardReferenceScale);
Returns the standardDomain of type StandardDomain from this RecordVariable
set the StandardDomain object for this RecordVariable
Example:
my $standardDomainAccess = new SSDS::StandardDomainAccess();
my $standardDomain = new SSDS::StandardDomain();
# set some attributes of the StandardDomain object
$standardDomain->name($someUniqueName);
...
$standardDomainAccess->insert($standardDomain);
# Find the StandardDomain just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundStandardDomains = $standardDomain->findByLikeName($someUniqueName);
# $foundStandardDomains now contains an array of objects (because findByLikeName returns a collection
my $foundStandardDomain = $$foundStandardDomains[0];
# Insert a RecordVariable
my $recordVariableAccess = new SSDS::RecordVariableAccess();
my $recordVariable = new SSDS::RecordVariable();
$recordVariable->name($someUniqueName);
$recordVariableAccess->insert($recordVariable);
# Find the RecordVariable just inserted and set the StandardDomain
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundRecordVariables = $recordVariableAccess->findByName($someUniqueName);
$foundRecordVariable = $$foundRecordVariables[0];
$foundRecordVariable->setStandardDomain($foundStandardDomain);
Returns the standardKeyword of type StandardKeyword from this RecordVariable
set the StandardKeyword object for this RecordVariable
Example:
my $standardKeywordAccess = new SSDS::StandardKeywordAccess();
my $standardKeyword = new SSDS::StandardKeyword();
# set some attributes of the StandardKeyword object
$standardKeyword->name($someUniqueName);
...
$standardKeywordAccess->insert($standardKeyword);
# Find the StandardKeyword just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundStandardKeywords = $standardKeyword->findByLikeName($someUniqueName);
# $foundStandardKeywords now contains an array of objects (because findByLikeName returns a collection
my $foundStandardKeyword = $$foundStandardKeywords[0];
# Insert a RecordVariable
my $recordVariableAccess = new SSDS::RecordVariableAccess();
my $recordVariable = new SSDS::RecordVariable();
$recordVariable->name($someUniqueName);
$recordVariableAccess->insert($recordVariable);
# Find the RecordVariable just inserted and set the StandardKeyword
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundRecordVariables = $recordVariableAccess->findByName($someUniqueName);
$foundRecordVariable = $$foundRecordVariables[0];
$foundRecordVariable->setStandardKeyword($foundStandardKeyword);
Resource - An SSDS Resource object
Instantiate an SSDS::Resource object
The following methods may be used to get or set any of the attributes of a Resource object (each attribute is both a setter and getter):
id name description startDate endDate dateRange uriString uri url webAccessible contentLength mimeType person resourceType resourceBLOB keywords
Note: the get_attribute_names() method will return this list of attributes
Example:
my $resourceAccess = new SSDS::ResourceAccess();
my $resource = $resourceAccess->findByPK(5777);
set the name for this Resource
set the description for this Resource
set the startDate for this Resource
set the endDate for this Resource
Returns the dateRange of type IDateRange from this Resource
set the uriString for this Resource
Return 1 if Resource is webAccessible, otherwise returns 0.
set the contentLength for this Resource
set the mimeType for this Resource
Returns the person of type Person from this Resource
set the Person object for this Resource
Example:
my $personAccess = new SSDS::PersonAccess();
my $person = new SSDS::Person();
# set some attributes of the Person object
$person->name($someUniqueName);
...
$personAccess->insert($person);
# Find the Person just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundPersons = $person->findByLikeName($someUniqueName);
# $foundPersons now contains an array of objects (because findByLikeName returns a collection
my $foundPerson = $$foundPersons[0];
# Insert a Resource
my $resourceAccess = new SSDS::ResourceAccess();
my $resource = new SSDS::Resource();
$resource->name($someUniqueName);
$resourceAccess->insert($resource);
# Find the Resource just inserted and set the Person
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundResources = $resourceAccess->findByName($someUniqueName);
$foundResource = $$foundResources[0];
$foundResource->setPerson($foundPerson);
Returns the resourceType of type ResourceType from this Resource
set the ResourceType object for this Resource
Example:
my $resourceTypeAccess = new SSDS::ResourceTypeAccess();
my $resourceType = new SSDS::ResourceType();
# set some attributes of the ResourceType object
$resourceType->name($someUniqueName);
...
$resourceTypeAccess->insert($resourceType);
# Find the ResourceType just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundResourceTypes = $resourceType->findByLikeName($someUniqueName);
# $foundResourceTypes now contains an array of objects (because findByLikeName returns a collection
my $foundResourceType = $$foundResourceTypes[0];
# Insert a Resource
my $resourceAccess = new SSDS::ResourceAccess();
my $resource = new SSDS::Resource();
$resource->name($someUniqueName);
$resourceAccess->insert($resource);
# Find the Resource just inserted and set the ResourceType
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundResources = $resourceAccess->findByName($someUniqueName);
$foundResource = $$foundResources[0];
$foundResource->setResourceType($foundResourceType);
Returns the resourceBLOB of type ResourceBLOB from this Resource
set the ResourceBLOB object for this Resource
Example:
my $resourceBLOBAccess = new SSDS::ResourceBLOBAccess();
my $resourceBLOB = new SSDS::ResourceBLOB();
# set some attributes of the ResourceBLOB object
$resourceBLOB->name($someUniqueName);
...
$resourceBLOBAccess->insert($resourceBLOB);
# Find the ResourceBLOB just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundResourceBLOBs = $resourceBLOB->findByLikeName($someUniqueName);
# $foundResourceBLOBs now contains an array of objects (because findByLikeName returns a collection
my $foundResourceBLOB = $$foundResourceBLOBs[0];
# Insert a Resource
my $resourceAccess = new SSDS::ResourceAccess();
my $resource = new SSDS::Resource();
$resource->name($someUniqueName);
$resourceAccess->insert($resource);
# Find the Resource just inserted and set the ResourceBLOB
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundResources = $resourceAccess->findByName($someUniqueName);
$foundResource = $$foundResources[0];
$foundResource->setResourceBLOB($foundResourceBLOB);
Returns the keywords of type Collection from this Resource
add the Keyword object for this Resource
Example:
my $keywordAccess = new SSDS::KeywordAccess();
my $keyword = new SSDS::Keyword();
# set some attributes of the Keyword object
$keyword->name($someUniqueName);
...
$keywordAccess->insert($keyword);
# Find the Keyword just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundKeywords = $keyword->findByLikeName($someUniqueName);
# $foundKeywords now contains an array of objects (because findByLikeName returns a collection
my $foundKeyword = $$foundKeywords[0];
# Insert a Resource
my $resourceAccess = new SSDS::ResourceAccess();
my $resource = new SSDS::Resource();
$resource->name($someUniqueName);
$resourceAccess->insert($resource);
# Find the Resource just inserted and set the Keyword
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundResources = $resourceAccess->findByName($someUniqueName);
$foundResource = $$foundResources[0];
$foundResource->addKeyword($foundKeyword);
rem the RemoveKeyword object for this Resource
Example:
my $removeKeywordAccess = new SSDS::RemoveKeywordAccess();
my $removeKeyword = new SSDS::RemoveKeyword();
# set some attributes of the RemoveKeyword object
$removeKeyword->name($someUniqueName);
...
$removeKeywordAccess->insert($removeKeyword);
# Find the RemoveKeyword just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundRemoveKeywords = $removeKeyword->findByLikeName($someUniqueName);
# $foundRemoveKeywords now contains an array of objects (because findByLikeName returns a collection
my $foundRemoveKeyword = $$foundRemoveKeywords[0];
# Insert a Resource
my $resourceAccess = new SSDS::ResourceAccess();
my $resource = new SSDS::Resource();
$resource->name($someUniqueName);
$resourceAccess->insert($resource);
# Find the Resource just inserted and set the RemoveKeyword
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundResources = $resourceAccess->findByName($someUniqueName);
$foundResource = $$foundResources[0];
$foundResource->removeKeyword($foundRemoveKeyword);
ResourceBLOB - An SSDS ResourceBLOB object
Instantiate an SSDS::ResourceBLOB object
The following methods may be used to get or set any of the attributes of a ResourceBLOB object (each attribute is both a setter and getter):
id name description byteArray
Note: the get_attribute_names() method will return this list of attributes
Example:
my $resourceBLOBAccess = new SSDS::ResourceBLOBAccess();
my $resourceBLOB = $resourceBLOBAccess->findByPK(5777);
set the name for this ResourceBLOB
set the description for this ResourceBLOB
ResourceType - An SSDS ResourceType object
Instantiate an SSDS::ResourceType object
The following methods may be used to get or set any of the attributes of a ResourceType object (each attribute is both a setter and getter):
id name description
Note: the get_attribute_names() method will return this list of attributes
Example:
my $resourceTypeAccess = new SSDS::ResourceTypeAccess();
my $resourceType = $resourceTypeAccess->findByPK(5777);
set the name for this ResourceType
set the description for this ResourceType
Software - An SSDS Software object
Instantiate an SSDS::Software object
The following methods may be used to get or set any of the attributes of a Software object (each attribute is both a setter and getter):
id name description uriString uri url softwareVersion person resources
Note: the get_attribute_names() method will return this list of attributes
Example:
my $softwareAccess = new SSDS::SoftwareAccess();
my $software = $softwareAccess->findByPK(5777);
set the name for this Software
set the description for this Software
set the uriString for this Software
set the softwareVersion for this Software
Returns the person of type Person from this Software
set the Person object for this Software
Example:
my $personAccess = new SSDS::PersonAccess();
my $person = new SSDS::Person();
# set some attributes of the Person object
$person->name($someUniqueName);
...
$personAccess->insert($person);
# Find the Person just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundPersons = $person->findByLikeName($someUniqueName);
# $foundPersons now contains an array of objects (because findByLikeName returns a collection
my $foundPerson = $$foundPersons[0];
# Insert a Software
my $softwareAccess = new SSDS::SoftwareAccess();
my $software = new SSDS::Software();
$software->name($someUniqueName);
$softwareAccess->insert($software);
# Find the Software just inserted and set the Person
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundSoftwares = $softwareAccess->findByName($someUniqueName);
$foundSoftware = $$foundSoftwares[0];
$foundSoftware->setPerson($foundPerson);
Returns the resources of type Collection from this Software
add the Resource object for this Software
Example:
my $resourceAccess = new SSDS::ResourceAccess();
my $resource = new SSDS::Resource();
# set some attributes of the Resource object
$resource->name($someUniqueName);
...
$resourceAccess->insert($resource);
# Find the Resource just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundResources = $resource->findByLikeName($someUniqueName);
# $foundResources now contains an array of objects (because findByLikeName returns a collection
my $foundResource = $$foundResources[0];
# Insert a Software
my $softwareAccess = new SSDS::SoftwareAccess();
my $software = new SSDS::Software();
$software->name($someUniqueName);
$softwareAccess->insert($software);
# Find the Software just inserted and set the Resource
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundSoftwares = $softwareAccess->findByName($someUniqueName);
$foundSoftware = $$foundSoftwares[0];
$foundSoftware->addResource($foundResource);
rem the RemoveResource object for this Software
Example:
my $removeResourceAccess = new SSDS::RemoveResourceAccess();
my $removeResource = new SSDS::RemoveResource();
# set some attributes of the RemoveResource object
$removeResource->name($someUniqueName);
...
$removeResourceAccess->insert($removeResource);
# Find the RemoveResource just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundRemoveResources = $removeResource->findByLikeName($someUniqueName);
# $foundRemoveResources now contains an array of objects (because findByLikeName returns a collection
my $foundRemoveResource = $$foundRemoveResources[0];
# Insert a Software
my $softwareAccess = new SSDS::SoftwareAccess();
my $software = new SSDS::Software();
$software->name($someUniqueName);
$softwareAccess->insert($software);
# Find the Software just inserted and set the RemoveResource
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundSoftwares = $softwareAccess->findByName($someUniqueName);
$foundSoftware = $$foundSoftwares[0];
$foundSoftware->removeResource($foundRemoveResource);
StandardDomain - An SSDS StandardDomain object
Instantiate an SSDS::StandardDomain object
The following methods may be used to get or set any of the attributes of a StandardDomain object (each attribute is both a setter and getter):
id name description
Note: the get_attribute_names() method will return this list of attributes
Example:
my $standardDomainAccess = new SSDS::StandardDomainAccess();
my $standardDomain = $standardDomainAccess->findByPK(5777);
set the name for this StandardDomain
set the description for this StandardDomain
StandardKeyword - An SSDS StandardKeyword object
Instantiate an SSDS::StandardKeyword object
The following methods may be used to get or set any of the attributes of a StandardKeyword object (each attribute is both a setter and getter):
id name description
Note: the get_attribute_names() method will return this list of attributes
Example:
my $standardKeywordAccess = new SSDS::StandardKeywordAccess();
my $standardKeyword = $standardKeywordAccess->findByPK(5777);
set the name for this StandardKeyword
set the description for this StandardKeyword
StandardReferenceScale - An SSDS StandardReferenceScale object
Instantiate an SSDS::StandardReferenceScale object
The following methods may be used to get or set any of the attributes of a StandardReferenceScale object (each attribute is both a setter and getter):
id name description
Note: the get_attribute_names() method will return this list of attributes
Example:
my $standardReferenceScaleAccess = new SSDS::StandardReferenceScaleAccess();
my $standardReferenceScale = $standardReferenceScaleAccess->findByPK(5777);
set the name for this StandardReferenceScale
set the description for this StandardReferenceScale
StandardUnit - An SSDS StandardUnit object
Instantiate an SSDS::StandardUnit object
The following methods may be used to get or set any of the attributes of a StandardUnit object (each attribute is both a setter and getter):
id name description longName symbol
Note: the get_attribute_names() method will return this list of attributes
Example:
my $standardUnitAccess = new SSDS::StandardUnitAccess();
my $standardUnit = $standardUnitAccess->findByPK(5777);
set the name for this StandardUnit
set the description for this StandardUnit
set the longName for this StandardUnit
set the symbol for this StandardUnit
StandardVariable - An SSDS StandardVariable object
Instantiate an SSDS::StandardVariable object
The following methods may be used to get or set any of the attributes of a StandardVariable object (each attribute is both a setter and getter):
id name namespaceUriString namespaceUri description referenceScale standardUnits
Note: the get_attribute_names() method will return this list of attributes
Example:
my $standardVariableAccess = new SSDS::StandardVariableAccess();
my $standardVariable = $standardVariableAccess->findByPK(5777);
set the name for this StandardVariable
set the namespaceUriString for this StandardVariable
set the description for this StandardVariable
set the referenceScale for this StandardVariable
Returns the standardUnits of type Collection from this StandardVariable
add the StandardUnit object for this StandardVariable
Example:
my $standardUnitAccess = new SSDS::StandardUnitAccess();
my $standardUnit = new SSDS::StandardUnit();
# set some attributes of the StandardUnit object
$standardUnit->name($someUniqueName);
...
$standardUnitAccess->insert($standardUnit);
# Find the StandardUnit just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundStandardUnits = $standardUnit->findByLikeName($someUniqueName);
# $foundStandardUnits now contains an array of objects (because findByLikeName returns a collection
my $foundStandardUnit = $$foundStandardUnits[0];
# Insert a StandardVariable
my $standardVariableAccess = new SSDS::StandardVariableAccess();
my $standardVariable = new SSDS::StandardVariable();
$standardVariable->name($someUniqueName);
$standardVariableAccess->insert($standardVariable);
# Find the StandardVariable just inserted and set the StandardUnit
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundStandardVariables = $standardVariableAccess->findByName($someUniqueName);
$foundStandardVariable = $$foundStandardVariables[0];
$foundStandardVariable->addStandardUnit($foundStandardUnit);
rem the RemoveStandardUnit object for this StandardVariable
Example:
my $removeStandardUnitAccess = new SSDS::RemoveStandardUnitAccess();
my $removeStandardUnit = new SSDS::RemoveStandardUnit();
# set some attributes of the RemoveStandardUnit object
$removeStandardUnit->name($someUniqueName);
...
$removeStandardUnitAccess->insert($removeStandardUnit);
# Find the RemoveStandardUnit just inserted so that we know its ID
# Note - Access class methods may vary from those shown in this example
my $foundRemoveStandardUnits = $removeStandardUnit->findByLikeName($someUniqueName);
# $foundRemoveStandardUnits now contains an array of objects (because findByLikeName returns a collection
my $foundRemoveStandardUnit = $$foundRemoveStandardUnits[0];
# Insert a StandardVariable
my $standardVariableAccess = new SSDS::StandardVariableAccess();
my $standardVariable = new SSDS::StandardVariable();
$standardVariable->name($someUniqueName);
$standardVariableAccess->insert($standardVariable);
# Find the StandardVariable just inserted and set the RemoveStandardUnit
# Note - Again, access class methods will vary, findByName
# is just an example and does not exist for all classes
$foundStandardVariables = $standardVariableAccess->findByName($someUniqueName);
$foundStandardVariable = $$foundStandardVariables[0];
$foundStandardVariable->removeStandardUnit($foundRemoveStandardUnit);
UserGroup - An SSDS UserGroup object
Instantiate an SSDS::UserGroup object
The following methods may be used to get or set any of the attributes of a UserGroup object (each attribute is both a setter and getter):
id groupName
Note: the get_attribute_names() method will return this list of attributes
Example:
my $userGroupAccess = new SSDS::UserGroupAccess();
my $userGroup = $userGroupAccess->findByPK(5777);
set the groupName for this UserGroup
AccessBean - Contains methods to query for and get Acce objects
Instantiate an SSDS::AccessBean object
Example:
my $accessBean = new SSDS::AccessBean();
my $acce = $accessBean->findByPK(5777);
getSessionContext in the database.
return the Acce with the ID = long $id, boolean $returnFullObjectGraph.
Example:
my $accessBean = new SSDS::AccessBean();
my $acce = $accessBean->findById(5777);
return a list of Acces
countFindAllIDs in the database.
return a list of Acces
return a list of Acces
return a list of Acces
insert IMetadataObject $insertRecord in the database.
update IMetadataObject $updateRecord in the database.
delete IMetadataObject $deleteRecord in the database.
makePersistent IMetadataObject $metadataObject in the database.
makeTransient IMetadataObject $deleteRecord in the database.
ejbActivate in the database.
ejbPassivate in the database.
ejbRemove in the database.
ejbPostCreate in the database.
DataContainerAccess - Contains methods to query for and get DataContainer objects
Instantiate an SSDS::DataContainerAccess object
Example:
my $dataContainerAccess = new SSDS::DataContainerAccess();
my $dataContainer = $dataContainerAccess->findByPK(5777);
ejbCreate in the database.
return a list of DataContainers where String $name, boolean $exactMatch, String $orderByPropertyName, String $ascendingOrDescending, boolean $returnFullObjectGraph matches the DataContainer name.
countFindByName String $name, boolean $exactMatch in the database.
return a list of DataContainers
return a list of DataContainers
countFindByDataContainerTypeAndName String $dataContainerType, String $name, boolean $exactMatch in the database.
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
countFindByDODSURLString String $dodsUrlString, boolean $exactMatch in the database.
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
countFindByKeywordName String $keywordName, boolean $exactMatch, String $orderByPropertyName, String $ascendingOrDescending, boolean $returnFullObjectGraph in the database.
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
return a list of DataContainers
DataContainerGroupAccess - Contains methods to query for and get DataContainerGroup objects
Instantiate an SSDS::DataContainerGroupAccess object
Example:
my $dataContainerGroupAccess = new SSDS::DataContainerGroupAccess();
my $dataContainerGroup = $dataContainerGroupAccess->findByPK(5777);
ejbCreate in the database.
return a list of DataContainerGroups where String $name, boolean $exactMatch, String $orderByPropertyName, String $ascendingOrDescending, boolean $returnFullObjectGraph matches the DataContainerGroup name.
return a list of DataContainerGroups
return a list of DataContainerGroups
DataProducerAccess - Contains methods to query for and get DataProducer objects
Instantiate an SSDS::DataProducerAccess object
Example:
my $dataProducerAccess = new SSDS::DataProducerAccess();
my $dataProducer = $dataProducerAccess->findByPK(5777);
ejbCreate in the database.
return a list of DataProducers
countFindByProperties String $name, boolean $exactMatch, String $dataProducerType, Date $startDate, boolean $boundedByStartDate, Date $endDate, boolean $boundedByEndDate, Double $geospatialLatMin, Double $geospatialLatMax, Double $geospatialLonMin, Double $geospatialLonMax, Float $geospatialDepthMin, Float $geospatialDepthMax, Float $geospatialBenthicAltitudeMin, Float $geospatialBenthicAltitudeMax, String $hostName, boolean $exactHostNameMatch in the database.
return a list of DataProducers where String $name, boolean $exactMatch, String $orderByPropertyName, String $ascendingOrDescending, boolean $returnFullObjectGraph matches the DataProducer name.
countFindByName String $name, boolean $exactMatch in the database.
return a list of DataProducers
countFindByDataProducerTypeAndName String $dataProducerType, String $name, boolean $exactMatch in the database.
return a list of DataProducers
countFindParentlessDeployments in the database.
return a list of DataProducers
countFindParentlessDataProducers in the database.
return a list of DataProducers
countFindByDateRangeAndName Date $startDate, boolean $boundedByStartDate, Date $endDate, boolean $boundedByEndDate, String $name, boolean $exactMatch in the database.
return a list of DataProducers
countFindByGeospatialCube Double $geospatialLatMin, Double $geospatialLatMax, Double $geospatialLonMin, Double $geospatialLonMax, Float $geospatialVerticalMin, Float $geospatialVerticalMax in the database.
return a list of DataProducers
countFindByTimeAndGeospatialCube Date $startDate, boolean $boundedByStartDate, Date $endDate, boolean $boundedByEndDate, Double $geospatialLatMin, Double $geospatialLatMax, Double $geospatialLonMin, Double $geospatialLonMax, Float $geospatialVerticalMin, Float $geospatialVerticalMax in the database.
return a list of DataProducers where String $name, boolean $exactMatch, Double $geospatialLatMin, Double $geospatialLatMax, Double $geospatialLonMin, Double $geospatialLonMax, Float $geospatialVerticalMin, Float $geospatialVerticalMax, String $orderByPropertyName, String $ascendingOrDescending, boolean $returnFullObjectGraph matches the DataProducer name.
countFindByNameAndGeospatialCube String $name, boolean $exactMatch, Double $geospatialLatMin, Double $geospatialLatMax, Double $geospatialLonMin, Double $geospatialLonMax, Float $geospatialVerticalMin, Float $geospatialVerticalMax in the database.
return a list of DataProducers where String $name, boolean $exactMatch, Date $startDate, boolean $boundedByStartDate, Date $endDate, boolean $boundedByEndDate, Double $geospatialLatMin, Double $geospatialLatMax, Double $geospatialLonMin, Double $geospatialLonMax, Float $geospatialVerticalMin, Float $geospatialVerticalMax, String $orderByPropertyName, String $ascendingOrDescending, boolean $returnFullObjectGraph matches the DataProducer name.
countFindByNameAndTimeAndGeospatialCube String $name, boolean $exactMatch, Date $startDate, boolean $boundedByStartDate, Date $endDate, boolean $boundedByEndDate, Double $geospatialLatMin, Double $geospatialLatMax, Double $geospatialLonMin, Double $geospatialLonMax, Float $geospatialVerticalMin, Float $geospatialVerticalMax in the database.
return a list of DataProducers
countFindByHostName String $hostName, boolean $exactMatch in the database.
return a list of DataProducers
countFindByPerson Person $person in the database.
return a list of DataProducers
return a list of DataProducers
return a list of DataProducers
return a list of DataProducers
return a list of DataProducers
return a list of DataProducers where String $name, boolean $exactMatch, String $orderByPropertyName, String $ascendingOrDescending, boolean $returnFullObjectGraph matches the DataProducer name.
return a list of DataProducers
return a list of DataProducers
return a list of DataProducers
return a list of DataProducers
return a list of DataProducers
return a list of DataProducers
return a list of DataProducers
countFindChildDataProducers DataProducer $dataProducer in the database.
return a list of DataProducers
return a list of DataProducers
countFindByDataProducerGroupName String $dataProducerGroupName, boolean $exactMatch in the database.
return a list of DataProducers
return a list of DataProducers
return a list of DataProducers
return a list of DataProducers
return a list of DataProducers
return a list of DataProducers
return a list of DataProducers
addChildDataProducer DataProducer $parentDataProducer, DataProducer $childDataProducer in the database.
addResource DataProducer $dataProducer, Resource $resourceToAdd in the database.
removeResource DataProducer $dataProducer, Resource $resource in the database.
createDuplicateDeepDeployment DataProducer $deploymentToCopy, Date $newStartDate, boolean $closeOld, Date $oldEndDate, String $newHeadDeploymentName, String $baseDataStreamUri in the database.
deepDelete DataProducer $dataProducer in the database.
makeDeepTransient DataProducer $dataProducer in the database.
DataProducerGroupAccess - Contains methods to query for and get DataProducerGroup objects
Instantiate an SSDS::DataProducerGroupAccess object
Example:
my $dataProducerGroupAccess = new SSDS::DataProducerGroupAccess();
my $dataProducerGroup = $dataProducerGroupAccess->findByPK(5777);
ejbCreate in the database.
return a list of DataProducerGroups where String $name, boolean $exactMatch, String $orderByPropertyName, String $ascendingOrDescending, boolean $returnFullObjectGraph matches the DataProducerGroup name.
return a list of DataProducerGroups
DeviceAccess - Contains methods to query for and get Device objects
Instantiate an SSDS::DeviceAccess object
Example:
my $deviceAccess = new SSDS::DeviceAccess();
my $device = $deviceAccess->findByPK(5777);
ejbCreate in the database.
return a list of Devices
return a list of Devices where String $name, boolean $exactMatch, String $orderByPropertyName, String $ascendingOrDescending, boolean $returnFullObjectGraph matches the Device name.
return a list of Devices where String $name, boolean $nameExactMatch, String $mfgName, boolean $mfgNameExactMatch, String $mfgModel, boolean $mfgModelExactMatch, String $mfgSerialNumber, boolean $mfgSerialNumberExactMatch, String $orderByPropertyName, String $ascendingOrDescending, boolean $returnFullObjectGraph matches the Device name.
return a list of Devices
return a list of Devices
return a list of Devices
return a list of Devices
return a list of Devices
return a list of Devices
return a list of Devices
return a list of Devices
return a list of Devices
return a list of Devices
DeviceTypeAccess - Contains methods to query for and get DeviceType objects
Instantiate an SSDS::DeviceTypeAccess object
Example:
my $deviceTypeAccess = new SSDS::DeviceTypeAccess();
my $deviceType = $deviceTypeAccess->findByPK(5777);
ejbCreate in the database.
return a list of DeviceTypes where String $name, boolean $returnFullObjectGraph matches the DeviceType name.
return a list of DeviceTypes where String $likeName, String $orderByPropertyName, String $ascendingOrDescending, boolean $returnFullObjectGraph matches any part of the DeviceType name.
return a list of DeviceTypes
EventAccess - Contains methods to query for and get Event objects
Instantiate an SSDS::EventAccess object
Example:
my $eventAccess = new SSDS::EventAccess();
my $event = $eventAccess->findByPK(5777);
ejbCreate in the database.
return a list of Events where String $name matches the Event name.
return a list of Events where String $likeName matches any part of the Event name.
return a list of Events where String $name, Date $startDate, Date $endDate matches the Event name.
return a list of Events
return a list of Events
KeywordAccess - Contains methods to query for and get Keyword objects
Instantiate an SSDS::KeywordAccess object
Example:
my $keywordAccess = new SSDS::KeywordAccess();
my $keyword = $keywordAccess->findByPK(5777);
ejbCreate in the database.
return a list of Keywords where String $name, boolean $exactMatch matches the Keyword name.
return a list of Keywords
return a list of Keywords
PersonAccess - Contains methods to query for and get Person objects
Instantiate an SSDS::PersonAccess object
Example:
my $personAccess = new SSDS::PersonAccess();
my $person = $personAccess->findByPK(5777);
ejbCreate in the database.
return a list of Persons
return a list of Persons
return a list of Persons
RecordVariableAccess - Contains methods to query for and get RecordVariable objects
Instantiate an SSDS::RecordVariableAccess object
Example:
my $recordVariableAccess = new SSDS::RecordVariableAccess();
my $recordVariable = $recordVariableAccess->findByPK(5777);
ejbCreate in the database.
return a list of RecordVariables where String $name, boolean $exactMatch, String $orderByPropertyName, String $ascendingOrDescending, boolean $returnFullObjectGraph matches the RecordVariable name.
return a list of RecordVariables
ResourceAccess - Contains methods to query for and get Resource objects
Instantiate an SSDS::ResourceAccess object
Example:
my $resourceAccess = new SSDS::ResourceAccess();
my $resource = $resourceAccess->findByPK(5777);
ejbCreate in the database.
return a list of Resources where String $name matches the Resource name.
return a list of Resources where String $likeName matches any part of the Resource name.
return a list of Resources
return a list of Resources
return a list of Resources
return a list of Resources
return a list of Resources
ResourceTypeAccess - Contains methods to query for and get ResourceType objects
Instantiate an SSDS::ResourceTypeAccess object
Example:
my $resourceTypeAccess = new SSDS::ResourceTypeAccess();
my $resourceType = $resourceTypeAccess->findByPK(5777);
ejbCreate in the database.
return a list of ResourceTypes where String $name, boolean $exactMatch matches the ResourceType name.
return a list of ResourceTypes
SoftwareAccess - Contains methods to query for and get Software objects
Instantiate an SSDS::SoftwareAccess object
Example:
my $softwareAccess = new SSDS::SoftwareAccess();
my $software = $softwareAccess->findByPK(5777);
ejbCreate in the database.
return a list of Softwares where String $name matches the Software name.
return a list of Softwares where String $likeName matches any part of the Software name.
return a list of Softwares
return a list of Softwares where String $name, String $version, boolean $returnFullObjectGraph matches the Software name.
return a list of Softwares
return a list of Softwares
StandardDomainAccess - Contains methods to query for and get StandardDomain objects
Instantiate an SSDS::StandardDomainAccess object
Example:
my $standardDomainAccess = new SSDS::StandardDomainAccess();
my $standardDomain = $standardDomainAccess->findByPK(5777);
ejbCreate in the database.
return a list of StandardDomains where String $name matches the StandardDomain name.
return a list of StandardDomains where String $likeName matches any part of the StandardDomain name.
return a list of StandardDomains
StandardKeywordAccess - Contains methods to query for and get StandardKeyword objects
Instantiate an SSDS::StandardKeywordAccess object
Example:
my $standardKeywordAccess = new SSDS::StandardKeywordAccess();
my $standardKeyword = $standardKeywordAccess->findByPK(5777);
ejbCreate in the database.
return a list of StandardKeywords where String $name matches the StandardKeyword name.
return a list of StandardKeywords where String $likeName matches any part of the StandardKeyword name.
return a list of StandardKeywords
StandardReferenceScaleAccess - Contains methods to query for and get StandardReferenceScale objects
Instantiate an SSDS::StandardReferenceScaleAccess object
Example:
my $standardReferenceScaleAccess = new SSDS::StandardReferenceScaleAccess();
my $standardReferenceScale = $standardReferenceScaleAccess->findByPK(5777);
ejbCreate in the database.
return a list of StandardReferenceScales where String $name matches the StandardReferenceScale name.
return a list of StandardReferenceScales where String $likeName matches any part of the StandardReferenceScale name.
return a list of StandardReferenceScales
StandardUnitAccess - Contains methods to query for and get StandardUnit objects
Instantiate an SSDS::StandardUnitAccess object
Example:
my $standardUnitAccess = new SSDS::StandardUnitAccess();
my $standardUnit = $standardUnitAccess->findByPK(5777);
ejbCreate in the database.
return a list of StandardUnits where String $name matches the StandardUnit name.
return a list of StandardUnits where String $likeName matches any part of the StandardUnit name.
return a list of StandardUnits
return a list of StandardUnits
return a list of StandardUnits
StandardVariableAccess - Contains methods to query for and get StandardVariable objects
Instantiate an SSDS::StandardVariableAccess object
Example:
my $standardVariableAccess = new SSDS::StandardVariableAccess();
my $standardVariable = $standardVariableAccess->findByPK(5777);
ejbCreate in the database.
return a list of StandardVariables where String $name, String $referenceScale matches the StandardVariable name.
return a list of StandardVariables where String $name matches the StandardVariable name.
return a list of StandardVariables where String $likeName matches any part of the StandardVariable name.
return a list of StandardVariables
return a list of StandardVariables
return a list of StandardVariables
return a list of StandardVariables
return a list of StandardVariables
UserGroupAccess - Contains methods to query for and get UserGroup objects
Instantiate an SSDS::UserGroupAccess object
Example:
my $userGroupAccess = new SSDS::UserGroupAccess();
my $userGroup = $userGroupAccess->findByPK(5777);
ejbCreate in the database.
return a list of UserGroups
countFindByGroupName String $groupName, boolean $exactMatch in the database.
return a list of UserGroups
countFindAllGroupNames in the database.