Product Details Elestore
Elestore administrates and stores all the content of product
catalogs, data sheets and similar publications for use in
various media, particularly for paper, e-paper and HTML with
special focus on paper and e-paper. Elestore closely communicates
and co-operates with Elepub, the Object Database Publishing
System, and provides the data, which is formatted and visualized
Application and Data Server
Elestore was designed to act as both an Application Server
as well as a Data Server. As Data Server it can serve up so
called Master Data to existing systems. Master Data in Elestore
can be presented and served as relational structures, which
can be accessed using relational methods like SQL or ODBC.
The object structures contained and managed by Elestore can
optionally be accessed via CORBA (Common Object Request Broker
Architecture), via an API or can be written out to XML structures.
Integration with existing systems
Data objects administrated by Elestore can remain physically
stored in existing external databases. This avoids data redundancy
and makes data in ERP and other databases logically accessible
to Elestore without the need to physically import it. Still,
Elestore and Elepub view such data similar to data stored
Object oriented storage
Elestore administrates different types of data objects of
arbitrary, dynamic and changing complexity. This is why Elestore
was designed as a fully object-oriented system. The object-oriented
nature is hidden from the user wherever it makes sense and
where it is possible while in some cases such as for data
inheritance the object-oriented features are voluntarily made
known and available to the user to profit from them.
Objects can also be imported from relational
databases and exported to relational databases combining the
advantages of both object-orientation and conventional relational
Data inheritance avoids data redundancy and substantially
eases the maintenance of major data objects. Therefore, Elestore
provides data inheritance through the use of "mother
objects", which act as templates providing default attributes
and values to its children objects, which inherit from their
mother all those attributes and values for which they do not
(need to) provide their own values.
Attributes and AttributeSets
There is a very large collection of different pre-defined
attributes (fields), from which articles can be composed.
AttributeSets are collections of such attributes, which are
typically assigned to mother article objects. AttributeSets
can be composed from an arbitrary collection of attributes
To create an attribute set the user simply
selects any number of existing attributes and creates the
set. Article objects and especially mother objects are then
assigned to such attribute sets and thereby they inherit all
attributes as defined in the particular set.
Article objects are composed from many different data objects
(fields) of different types some of which are stored as independent
object instances. Attributes (fields) of article objects typically
vary from article to article, therefore Elestore supports
different collections of article attributes called AttributeSets.
Elestore differentiates between different article types having
different purposes and behavior. "Mother articles"
act as templates and inherit their attributes and values to
real articles, which are identical in most aspects and differ
only in a few attributes such as technical details, dimensions,
price, stock etc.
Article objects come with a very comprehensive set of predefined
attributes (fields) especially supporting different types
of article numbers and many technical, date and commercial
data fields. These standard attributes are common to all article
types and can be enhanced by the user through AttributeSets.
Each article object can be linked to an AttributeSet and thereby
receive its own set of attributes (fields) extending the already
comprehensive standard attributes. Typically, this is done
for mother articles only, which then inherit their AttributeSet
to their children articles.
Grouping and classification systems
Article objects can be linked to one or more grouping systems,
which are used for classifying and selecting articles. Each
grouping system is a multi-level tree created and edited by
the user to order (group) articles under different aspects.
Existing company specific and/or industry standard grouping
and classification systems are also supported and existing
grouping trees can be imported.
Virtual data objects
Article objects can partially consist of virtual data objects
(fields), which are only logically administrated in Elestore
without any physical value stored inside Elestore. This allows
for a smooth integration of data that should remain in its
original database system, and be used by Elestore without
any replication. From the internal view of Elestore (and thereby
also of Elepub) virtual data objects are handled similar to
normal attributes stored inside Elestore although their values
are accessed from the external source (database). This is
Elestore's alternative for using external data without creating
copies of it.
The complex article data stored in Elestore can be viewed
and inspected in many different ways and forms. Special purpose
views facilitate the viewing, selection and inspection of
multi-lingual text objects. For easy translation the different
languages can also be presented side by side or in table views.
Text objects are formatted and multi-lingual long texts. Text
objects are of two different types:
- autonomous text objects for multiple use or as re-usable
part of other objects (articles, images)
- and dependent text objects, which are used only as a
logical part of one other object (article, image).
Dependent text objects
Dependent text objects are logically an integral part of one
other object of another class such as article or image. These
text objects are automatically administrated by their host
objects and used only as part of their host object.
Autonomous text objects
These text objects represent re-usable text entities, which
are used autonomously and/or as part of several other objects.
Autonomous objects can be used by several other objects of
different types (articles, images). This avoids data redundancy
where texts are used by different objects or for different
Each text object can consist of several language variants.
When accessing text objects they answer their currently selected
language variant. Therefore, whenever text objects are used
there is typically no need to define a specific language variant.
This feature of Elestore enables Elepub to automatically switch
entire publications from one language to another by simply
changing one central
language selection setting.
Storage of text objects in XML
Text objects are stored in XML format together with all knows
formatting attributes. Text objects can be exported to ASCII
or RTF format.
Text objects are edited in an RTF editor supporting all major
RTF attributes. RTF text formatting attributes are stored
as part of the XML text structure.
Elestore comprises a basic image database making all needed
images available both to article objects and as autonomous
objects not only but primarily for use in Elepub. Similar
to text objects, image objects can be stored in different
variants, i.e. formats, resolutions and views. Also similar
to text objects there are:
- autonomous image objects for arbitrary stand-alone use
or as re-usable part of other objects
- and dependent image objects, which are used only as a
logical part of one other object (article).
Images remain physically stored directly in the file system
and are only referenced from Elestore so that they remain
physically accessible in the usual way without any need for
import or export.
Sequences are arbitrary collections of different object types
such as articles, texts and images. Sequences define the order,
in which these objects are to be published in chapters, sections
and on pages etc.
Sequences are made up of sequence items, each of which points
to a specific data object of different type. Sequence items
can also hold a sub-sequence defining objects, which are dependent
to the top level item. This is how Elestore answers sequences
of different logically dependent objects particularly for
Elepub, which uses such sub-sequences for creating frame groups
or tables of dependent objects.
Relation objects create logical connections between objects
of different or of the same object type (class). There are
many different types of relations some of which are qualified
by a qualifier attribute, which is typically selected by the
user. In most cases relation objects are hidden from the user
and used to create dependencies between objects. As for the
storage of relation objects Elestore and Elepub create one
unified system where relations between data objects in Elestore
and publication objects in Elepub such as pages, frames etc.
are established and used.
Object import and export
All major object types can be imported from ASCII files or
from an ODBC database. The data import process can create
new objects and/or overwrite given attributes of existing
objects (partial import as update).
Accessing foreign databases
There are three ways of accessing external databases:
- via ExternalVirtualLinks physically connecting an article
attribute to a data field of an external database
- via ODBC to import from external databases
- via ODBC to export to external databases.
All user data objects can be exported to ASCII files or to
ODBC databases. For exporting data the object-oriented structures
inherent to Elestore are transformed into relational structures
so that conventional relational systems are fully supported.
For most major object types, namely for article and text objects,
Elestore fully supports XML for import and export (in case
of text objects XML is even used for the internal storage
as described in section text objects).
Running the Elestore software requires:
PC hardware: min. 1.300 MHz processor, 512
MB RAM, min. 300 MB free disk space
17" or 19" monitor with a resolution of 1.024 x
Operating system: Windows 2000, XP or NT 3.x or