Drupal 7 Module Development

Working with Content
As a general rule, large, rarely used classes should be placed into a
separate file while smaller or very frequently used classes should be
left in the .module file to avoid the overhead of finding the class when
needed. Additionally, classes that are typically used together can be
placed into a single file so that we'll need to load only a single file.
Let's create a new file in our module called artwork.controller.inc. Next, add that
file to the files[] array in the artwork.info file. In artwork.controller.inc, let's
start with just the following code:
class ArtworkController extends DrupalDefaultEntityController {
}
Now when our module is enabled, Drupal will scan all files in the files[] array
in artwork.info, find the ArtworkController class, and cache its location. Later
on, when some code tries to create a new instance of ArtworkController it will
lazy-load the artwork.controller.inc file, making the class available to be used.
Naturally the ArtworkController class needs to actually do something. We will add
additional methods to it as we go. There is already a load() method, inherited from
DrupalDefaultEntityController, as well as several others.
Most Drupal code prefers to work procedurally, however, even if the engine under
the hood is object-oriented. Therefore, like the node module we will provide a set
of utility API functions for us and other module developers to use.
function artwork_load($aid = NULL, $vid = NULL, $reset = FALSE) {
$aids = (isset($aid) ? array($aid) : array());
$conditions = (isset($vid) ? array('vid' => $vid) : array());
$artwork = artwork_load_multiple($aids, $conditions, $reset);
return $artwork ? reset($artwork) : FALSE;
}
function artwork_load_multiple($aids = array(), $conditions = array(),
$reset = FALSE) {
return entity_load('artwork', $aids, $conditions, $reset);
}
Note that we're actually passing all of the loading logic back to the entity_load()
function, which in turn will create a new instance of the ArtworkController as
needed and call the load() method on it. The load() method assumes that all
operations are multi-load. In fact, the entity system assumes multi-object operations
wherever possible. That makes loading multiple objects at the same time much
cheaper as we can load them all at once, while loading a single object is the exact
same operation. "One" is a special case of "many". We can now load one or a dozen
artwork objects with equal ease.
[ 162 ]