text:
|Message view
|« Date » · « Thread »
|« Date » · « Thread »
|svn commit: r1206895 [2/12] - in /incubator/ooo/ooo-site/trunk/content/udk/common: ./ man/ man/concept/ man/draft/ man/draft/scripting/ man/draft/scripting/DesignDoc/ man/images/ man/spec/ man/tasks/ man/tutorial/
|Sun, 27 Nov 2011 22:50:08 GMT
Added: incubator/ooo/ooo-site/trunk/content/udk/common/man/concept/streams.html URL: http://svn.apache.org/viewvc/incubator/ooo/ooo-site/trunk/content/udk/common/man/concept/streams.html?rev=1206895&view=auto ============================================================================== --- incubator/ooo/ooo-site/trunk/content/udk/common/man/concept/streams.html (added) +++ incubator/ooo/ooo-site/trunk/content/udk/common/man/concept/streams.html Sun Nov 27 22:49:46 2011 @@ -0,0 +1,772 @@ +<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> + + + <title>Streaming interfaces</title> +<meta HTTP-EQUIV="content-type" CONTENT="text/html; charset=UTF-8"/> + + + +
 +
 +  +
 Streaming interfaces
 + 	 +  + 	 +
 +
 + + + +
 Abstract
 + +
This draft introduces the streaming interfaces (package + com.sun.star.uno.io) and gives some examples about how they can be + used.
 + +
 + Note: In some pictures there is a ignoreable 2 in the + interface names (e.g. XInputStream2).
 + + +
 Contents
 +
 +Introduction
 +The interfaces
 +
 +
 +
The 1st level : XInputStream/XOutputStream +
The 2nd level : XActiveDataSink/XActiveDataSource +
Chaining +
Piping +
The 3rd level : XActiveDataControl +
The 4th level : XConnectable +
Errorhandling +
 +
 +
Standard services
 +
 + + +
 Introduction
 + +
 +
 + This chapter introduces some notions that you will come across + later in this document.
 + +
 + A datasource is an object, that has some data. A datasink + is an object that gets some data. Note that no assumption is made + about how data is transfered, only the direction of dataflow is + fixed (Fig 1.). Note also, that one object can be datasource and + datasink at the same time, for example a filter receives data from + somewhere (=sink), modifies this data, and broadcasts this data again + (=source).
 +
 +  +

 + Datasources and datasinks can be active or + passive. +
 +
 + 1) A datasink is active + when in the thread of execution the datasink calls a method of + datasource to get some data. In this case, the datasource is + passive.
 +
 +  +

 + 2) A datasource is active + when in the thread of execution the datasource calls a method of + datasink to write some data. In this case, the datasink + is passive.

 +  +

 + Streams offer fixed interfaces to do the data transfer. + At the lowest level, streams transport bytes. Data does not need to be + transported in one piece but can be sliced into multiple pieces. To + reflect the two cases above, there exist inputstreams and + outputstreams. Inputstreams are used in the active + sink-passive source scenario and outputstreams are used in the + active source-passive sink scenario.

 + + +
 The interfaces
 + +
 +
The design of the streaming + interfaces had three major goals :

 +
 +
 + Easy to implement and short interface. Few interfaces to start with. + Extension interfaces to make the component more flexible and + reusable. +
Allow easy chaining and + piping of streams (see below). +
Symmetric interfaces. The input/output symmetry of the + problem should be reflected by the interfaces. +
 +
 +
Below you can find the results of the design. +

 + There is a kind of a four-level hierarchy indicated by the dotted lines. +

 +  +

 + Fig 5. The new streaming interfaces in a 4 level + structure

 + +
 The 1st level : XInputStream/XOutputStream
 + +
 +
A basic streaming facility can be + implemented with XInputStream or XOutputStream alone.

 + Example (see also the introduction chapter) :
 +
 + There is an object source that has some data, and an + object sink that wants to get some data. There are two possibilities + to fulfil the task : +

 + +
 +
 + source implements an XInputStream and sink reads + actively from it. In this case, source is a passive-data-source + and sink is an active-data-sink. +
sink implements an XOutputStream and source + writes actively into it. In this case, source is an + active-data-source and sink is a passive-data-sink. +
 +
 +
Sample implementation + ( for simplicity no error handling here ). +

 + +
//simple scenario : 200 bytes shall be transfered from source to target +//active sink, passive source scenario. +class source : public XInputStream, public .... +{ + ... + // set the actual position to zero + source() { index = 0; } + + // XinputStream.readBytes() + INT32 readBytes( Sequence<unsigned char> &seq , INT32 nBytes ) + { + // beware eof ! + INT32 nCopy = min( nBytes, 200-index ); + + // allocate memory for the requested number of bytes + seq.realloc( nCopy ); + + // put the data into the sequence + memcpy( seq.getArray() , &acData[index] , nCopy ); + + // increase actual position + index += nCopy; + + return nCopy; + } + + // XInputStream.skipBytes() + INT32 skipBytes( INT32 nBytes ) + { + // beware eof ! + INT32 nCopy = min( nBytes, 200-index ); + + // increase actual position + index += nCopy; + + return nCopy; + } + + // XInputStream.available() + INT32 available() + { + return 200-index; + } + + // XInputStream.closeInput() + void closeInput() + { + // no special closing procedure in this simple example + } + + ... +private: + unsigned char acData[200]; + INT32 index; +}; + + +// the active datasink +// No error or exception handling for simplicity +class sink : public XXXXXXX, ..... +{ + // method of interface XXXXXXX + void readFromStream( const Reference< XInputStream > &r ) + { + Sequence<unsigned char> seq(10); + + BOOL bContinue = TRUE; + + // number of bytes that have been read + INT32 nRead; + + while( bContinue ) { + // read from the inputstream in 10 byte steps + nRead = r->readBytes( seq , 10 ) + + // ... do something with seq + + // check, if eof has been reached + bContinue = ( 10 == nRead ); + } + // close the stream + r->closeInput(); + } +} + +///in main : +{ + Reference< XInterface > source; + Reference< XInterface > sink; + + // instantiate source and sink through some service. + .... + + // query the inputstream + Reference< XInputStream > input_stream( source , UNO_QUERY ); + + // query the sink + Reference< XXXXXXX > some_interface( sink , UNO_QUERY ); + + // do the reading + some_interface->readFromStream( input_stream ); +} +
 + +
 The 2nd level : XActiveDataSink2/XActiveDataSource2
 +
 +
To make the above sample code more + flexible, the sink class may + implement XActiveDataSink. Calling the setInputStream()-method + informs the sink from where to read the data. Thus the code becomes + more generic, (sink is only required to support the small + XActiveDataSink rather than Reference< XXXXXXX > ).
 +
 + When to start the data transfer, depends on the implementer of + XActiveDataSink. +
 +
 + Here there are three possibilities. +

 +
 +
 In the call to XActiveDataSink.setInputStream() the whole data + transfer is done. This is the worst possibility, because a user may + not expect a set-method to behave this way. + +
The call to + XActiveDataSink.setInputStream() starts a thread that does the + data transfer. This is a better solution, because the call is not + blocking. Nevertheless the user must still be aware, that everything + is well prepared for transfer when the call is made. + +
The call to XActiveDataSink2.setInputStream() just informs + the object where to read from. The start of data transfer is done + over another method. This may be the start()-method of + XActiveDataContro2 (see below). +
 + +
 +
The 3rd solution is by far the best one, because 1) + + 2) are more difficult to reuse and may lead to deadlocks, etc.
 +
 + Note that everything said about XActiveDataSink also holds for + XActiveDataSource.
 +
 + +
 2.2.1 Chaining
 +
 +
An interesting application of the first 2 interface-levels is + the chaining concept. +
 +
 + Imagine you have written the XInputStream implementation OFile, that + offers raw data stored in a file. Then you have an arbitrary + application, that has implemented XActiveDataSource. After you have + connected both objects via setInputStream(), you have the connection + shown in Fig. 6a.
 +
 +  +

 + Now a file shall be read, that uses a different file format. One + could either modify OFile or application to do the conversion, but + there is a better solution. An independent service OConverter can be + used, it implements XActiveDataSink and XInputStream. Now the input + stream of OFile can be plugged into OConverter and the input stream + of OConverter can be plugged into application (Fig 6.b).

 + Note that it is not necessary to change either application or OFile, + only the plugging before the start of data transfer must be adapted. + If desired, this may be decided at runtime.
 +
 + Note also, that you can easily insert more converters into the + chain. +
 +
 + +
The following code samples show how plugging is done. +/// Plugging for Fig 6b (without error handling) +{ + Reference<XInterface > application; + Reference<XInterface > OConverter; + Reference<XInterface > OFile; + + // instantiate the three objects via services, put them into the above references + ..... + + // query the interfaces + Reference< XInputStream > aFileInputStream( OFile , UNO_QUERY ); + Reference< XInputStream > aConverterInputStream( OConverter , UNO_QUERY ); + Reference< XActiveDataSink > aConverterSink( OConverter , UNO_QUERY ); + Reference< XActiveDataSink > aApplicationSink( application , UNO_QUERY ); + + // plug the connection + aConverterSink.setInputStream( aFileInputStream ); + aApplicationSink.setInputStream( aConverterInputStream ); + + // start data transfer + ... +} +
 + +
 +
 + The following figure shows the resulting calling sequence for a + readBytes()-call for both cases.

 +  +
 +  +
 +
 + Note that the order of plugging may be significant if + data transfer is started with the setInputStream method. Again the + last line of the above sample code :

 + a) +
 +
 + +
{ + // plug the connection + aConverterSink.setInputStream( aFileInputStream ); // first connect passive parts. + aApplicationSink.setInputStream( aConverterInputStream ); // active player is connected last, + // no problems can arise +} + +b) +{ + // plug the connection + aApplicationSink.setInputStream( aConverterInputStream ); // application starts to read but OConverter + // is not connected to anything. + aConverterSink.setInputStream( aFileInputStream ); +} +
 + +
The problem can be avoided :
 + +
 +
 Use code sample a) instead of b) when plugging. ( Responsibility + is left to the user ). When b) is used, OConverter will throw an + exception. + +
OConverter can be designed, so that it can cope with the problem. If + it is not connected to anything, but its read()-method is called, it + could wait in a condition up to the moment when connection is + established. Note that this is not an ideal solution, if the + connection never gets established there remains a dead thread + without any sign of an error. It also must be implemented again and + again for each converter. + +
Do not start the data transfer with these set-methods. Better + use XActiveDataControl (see below) +
 + +
 +
 + Note : It can be quite difficult to implement a OConverter, that + modifies the number of bytes to read. The skipBytes(), readBytes() + and available()-methods must always return the requested number of + bytes, in such cases, converters must do at least some buffering on + their own. For such applications it is in general easier to + implement an output stream (and use pipes and threads to get the + desired interface, see below). However this may be too expensive in + some cases.
 +
 + +
 2.2.2 Piping
 + +
 +
Motivation :

 + For a lot of applications it is necessary to have more than one + active player in the game. Imagine you have a datasource that can + only write actively and a datasink that can only read actively and + you want to connect them. This can be done by a pipe. A pipe offers + an OutputStream to write to and an InputStream to read from. Thus it + must buffer the data that come in via XOutputStream.
 +
 + Fig. 9 shows a concrete example for a pipe. A file x is copied into + file y. OFileReader reads file x in certain slices. Each slice is + written via the output stream to OPipe. OFileWriter gets actively data + from OPipe and writes it directly into file y. The connection is + plugged with standard components (which still need to be + implemented), they can be used in other scenarios independent of + each other.
 +
 +  +

 + The following source code shows how the above connection is + established (for simplicity without error handling).

 + +
 +{ + Reference< XInterface > OFileWriter, OPipe, OFileReader; + + // instantiate them via a standard service + .... + + // get the interfaces + Reference< XActiveDataSink > sink( OFileWriter, UNO_QUERY ); + Reference< XOutputStream > pipeOut( OPipe , UNO_QUERY ); + Reference< XInputStream > pipeIn( OPipe , UNO_QUERY ); + Reference< XActiveDataSource > source( OFileReader , UNO_QUERY ); + + // do the plugging + sink.setInputStream( pipeIn ); + source.setOutputStream( pipeOut ); + // now work with the connection ( sink and source ) +} +
 + +
 +
 + Note : You can insert further filters and converters via chaining. + For example you can insert an instances of OConverter (above example) + between OFileWriter and OPipe.
 +
 + Note : A pipe can also be seen as a mechanism to transform an output + stream into an input stream at the costs of the buffer resources.
 +
 + Note : By exchanging OFileWriter with an object that implements + XActiveDataSink and XActiveDataSource, one could add a further + pipe. This shows the flexibility of the concept.
 +
 + +
 The 3rd level : XActiveDataControl
 + +
 +
The question 'when should data transfer start ?' is not solved + sufficiently. One can say that as soon as the last connection has + been plugged, the data starts to flow. That is not acceptable for + some applications. An generic interface is needed, which can one use + to initiate the data transfer. This is the role of + XActiveDataControl.
 +
 + XActiveDataControl should be implemented with XActiveDataSink or + XActiveDataSource, thus each active player in the game should + implement it.
 +
 + XActiveDataControl offers a non-blocking start()-method to initiate + data transfer. The terminate()-method should abort the data transfer + before it is normally finished. Usually this should be done by + calling the close()-method of the connected streams. See error + handling for further information.
 +
 +  +

 + +
 +To startup the above sample pipe, the following code is necessary : +{ + Reference< XInterface > OFileWriter, OPipe, OFileReader; + + // instantiate them via a standard service + .... + + // get the interfaces for plugging + Reference< XActiveDataSink > sink( OFileWriter, UNO_QUERY ); + Reference< XOutputStream > pipeOut( OPipe , UNO_QUERY ); + Reference< XInputStream > pipeIn( OPipe , UNO_QUERY ); + Reference< XActiveDataSource > source( OFileReader , UNO_QUERY ); + + // plug ( data transfer is not started ) + sink.setInputStream( pipeIn ); + source.setOutputStream( pipeOut ); + + // get the interfaces for starting + Reference< XActiveDataControl > controlSink( OFileWriter ); + Reference< XActiveDataControl > controlSource( OFileReader ); + + // start + controlSink.start(); // order of starting is not important, the whole connection already exists. + controlSource.start(); // it may be less expensive to start sink first, because OPipe + // may need less resources for buffering. +} +
 + +
XActiveDataControl also offers a listener administration.
 + +
 The 4th level : XConnectable
 + +
 +
The held references in Fig. 10 are unidirectional. There is no + generic way to get from OFileWriter to OFileReader. This maybe + interesting for further streaming administration services.
 +
 + Here now appears XConnectable on stage. Every class in the + connection should implement XConnectable. Below (Fig.11 and Fig. + 12) you find the extended version of the above examples.

 +
 + Fig + 11. Extended example (see fig. 6b). Each element in the connection + implements XConnectable and connects to their neighbours. Thus it is + possible to reach Application from OFile. The direction of the + connection (successor/predecessor) is determined by the direction + of dataflow.

 +
 + + Fig + 12. Extended example (see fig 10). Now every element of the + connection is reachable with one arbitrary element.
 +
 + The extra plugging work should not be left to the user. In order to + get this working with the least effort for the user, the + implementation of the XActiveDataSink.setInputStream() or + XActiveDataSource2.setOutputStream() must be modified the following + way:

 +
 +OFileWriter::setInputStream( const Reference< XInputStream > &r ) +{ + /// store the inputstream reference for later use + m_in = r; + + /// does the instance provide a XDataSourceRef ? + Reference< XConnectable > predecessor( r , UNO_QUERY ); + setPredecessor( predecessor ); +} + +application::setPredecessor( const Reference< XConnectable > &r ) +{ + /// if the references match, nothing needs to be done + if( m_pred != r ) { + /// store the reference for later use + m_pred = r; + + if( m_pred.is() ) { + /// set this instance as the sink ! + m_pred.setSuccessor( this ); + } + } +} + +
 +
 +
 + A similar implementation of for setSuccessor allows to get the + desired references with no extra work for the user.
 +
 + There now exists a ring reference, which raises a + deallocation-problem. This can be solved sufficiently, when in + close()-operations all references are explicitly deleted.

 + OConverter::closeInput()

 +
{ + /// send the close to the chained partner + getInputStream()->closeInput(); + + //.... do some tiding up, that is necessary when closing. + + /// release all references + setPredecessor( Reference< XConnectable >() ); + setSource( Reference< XConnectable >() ); + setInputStream( Reference< XInputStream >() ); +} +
 +
Note that any object, which does not support this XConnectable mechanism will interrupt the connection. + +
 +
 + The sense of XConnectable is maybe not very clear. Note that + implementing this underlying connection of elements will allow to + create standard services, that can help to establish and + administrate connections of streams. This may be an important reason + for using this new streaming interfaces, that's why you are strongly + encouraged to implement them. +

 + An use case may be a video stream, where the sink wants to change + some settings at source, but the sink doesn't know the source. It + can then use XConnectable to wander to the source, where it can + query on a known interface.

 + +
 2.5 Errorhandling
 + +
 +
This chapter deals with abnormal conditions that may occur when + using streams.

 +  +

 + Let's take the pipe example as a basis for discussion.
 +
 + In the normal case both FileReader and FileWriter start to do their + job. When FileReader has read all data from the file x and has + written all data into the outputstream, it must call closeOutput on + XOutputStream. This will disconnect OPipe and OFileReader, + OFileReader may be deleted. When OFileWriter tries to read beyond + eof, it realizes that it gets less bytes than questioned. This is + interpreted by OFileWriter as eof sign. It then calls closeInput on + the XInputStream and frees its own resources. The reference between + OPipe and OFileWriter is removed, OFileWriter and OPipe may be + deleted. +
 +
 + Possible error scenarios are :

 +
 +
 + Error during reading file x (OFileReader). In that case OFileReader + closes its internal resources, broadcasts an error to all listeners + and calls closeOutput() on outputstream. Note that OPipe and + OFileWriter cannot distinguish between a normal eof-close and a + error close (unless they are listeners). + +
Error during writing file y + (OFileWriter). In that case, OFileWriter closes its internal + resources, broadcasts an error to all listeners and calls + closeInput() (which will disconnect OFileWriter from OPipe ) on + inputstream. OFileReader is still writing on OPipe's outputstream. + At any time after the closeInput() call, OPipe may throw an + IOException, if OFileReader calls a write-method. OFileReader + catches the exception, calls closeOutput() on the outputstream, + which will disconnect OPipe from OFileReader. It may also broadcast + an error to all listeners. + +
Error in OPipe (e.g. buffer full). + At any time after the exceptional state has occurred, OPipe will + throw exceptions for every read call and every write call. + OFileReader and OFileWriter must then call + closeInput()/closeOutput() and broadcast an error. + +
terminate()-method on OFileReader or OFileWriter is called. + This can be handled very similar to the above error conditions, + except that the terminated()-handler must be called. +
 +
 +
 + Note that all above errors in general occur in a multi-threaded + environment. Especially situations as that the terminate()-method of + OFileWriter gets called when another thread is in the read-Method of + OPipe must be handled correctly. In this case, terminate must call + closeInput(), OPipe must return out of the reading thread with + eof-signature (less bytes read than questioned) and OFileWriter must + call only the terminated() but not the error() handler!.

 + + +
 Standard services
 + +
The following standard services have been implemented . Implementations +can be found in udk/io/source/stm. +The dll is stm.dll. +All implementations are thread safe. However it is probably not very +meaningful, if two threads read the same input stream at the same +time which thread gets which data is then arbitrary. + +
Note: All streams must be explicitly closed in order to free their resources +and release their ring references.
 + +
com.sun.star.uno.io.Pipe : +implements XOutputStream, XInputStream and +XConnectable
 +
Basic implementation (see fig 12) to connect +input stream and output stream. In general one thread is writing data +into the pipe and another is reading from the pipe. The pipe does the +necessary buffering in memory.
 + +
com.sun.star.uno.io.DataInputStream +: implements XDataInputStream, XActiveDataSink and +XConnectable
 +
Provides the XDataInputStream functionality. +Must be chained to another XInputStream (e.g. a pipe) to be +meaningful.
 + +
com.sun.star.uno.io.DataOutputStream +: implements XDataOutputStream, XActiveDataSource and +XConnectable
 +
Provides the XDataOutputStream functionality. +Must be chained to another XOutputStream (e.g. a pipe) to be +meaningful.
 + +
com.sun.star.uno.io.MarkableInputStream +: implements XMarkableStream, XInputStream, +XActiveDataSink and XConnectable
 +
Provides the +XMarkableStream functionality. When a mark is created, the +implementations buffers all further read data. Must be chained to +another inputstream to be meaningful.
 + +
com.sun.star.uno.io.MarkableOutputStream +: implements XMarkableStream, XOutputStream, +XActiveDataSource and XConnectable
 +
Provides the +XMarkableStream functionality. When a mark is created, the +implementations buffers all further written data. The data is written +further through the chain, when the mark is deleted. Even a flush +will not have any effect. Must be chained to another outputstream to +be meaningful.
 + +
com.sun.star.uno.io.ObjectInputStream +: implements XObjectInputStream, XActiveDataSink +and XConnectable
 +
Provides XObjectInputStream functionality. +All services of instances, that shall be read, must be registered +with the global service manager. All services must implement +XPersistObject. Must be chained to another XInputStream. Somewhere in +the chain must exist an XMarkableStream. +Be careful that all elements between this and XMarkableStream must +not buffer data ( otherwise the markable stream becomes +meaningless ) and one receives coincident results.
 + +
com.sun.star.uno.io.ObjectOutputStream +: implements XObjectOutputStream, XActiveDataSource and +XConnectable
 +
Provides XObjectOutputStream functionality. +All services, that shall be serialized, must implement +XPersistObject. Must be chained to another XOutputStream. +Somewhere in the chain must exist a XMarkableStream. Be +careful that all elements between this and XMarkableStream must +not buffer data ( otherwise the markable stream becomes +meaningless) and one receives coincident results.
 + +
 +
 + +
 Author: +  Joerg Budischewski + ($Date: 2004/11/27 07:50:15 $)
 + Copyright 2001 Sun Microsystems, Inc., 901 San Antonio Road, Palo Alto, CA + 94303 USA. +
 +	 +
 +
 + + Propchange: incubator/ooo/ooo-site/trunk/content/udk/common/man/concept/streams.html ------------------------------------------------------------------------------ svn:eol-style = native Added: incubator/ooo/ooo-site/trunk/content/udk/common/man/concept/string_invest.html URL: http://svn.apache.org/viewvc/incubator/ooo/ooo-site/trunk/content/udk/common/man/concept/string_invest.html?rev=1206895&view=auto ============================================================================== --- incubator/ooo/ooo-site/trunk/content/udk/common/man/concept/string_invest.html (added) +++ incubator/ooo/ooo-site/trunk/content/udk/common/man/concept/string_invest.html Sun Nov 27 22:49:46 2011 @@ -0,0 +1,12 @@ +<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" +"http://www.w3.org/TR/2000/REC-xhtml1-20000126/DTD/xhtml1-strict.dtd"> + + + <meta http-equiv="refresh" content="3; URL=http://wiki.services.openoffice.org/wiki/Uno/Binary/Analysis/String_Performance" /> +<meta HTTP-EQUIV="content-type" CONTENT="text/html; charset=UTF-8"> + + +
Redirecting....
 + + + Propchange: incubator/ooo/ooo-site/trunk/content/udk/common/man/concept/string_invest.html ------------------------------------------------------------------------------ svn:eol-style = native Added: incubator/ooo/ooo-site/trunk/content/udk/common/man/concept/uno_contexts.html URL: http://svn.apache.org/viewvc/incubator/ooo/ooo-site/trunk/content/udk/common/man/concept/uno_contexts.html?rev=1206895&view=auto ============================================================================== --- incubator/ooo/ooo-site/trunk/content/udk/common/man/concept/uno_contexts.html (added) +++ incubator/ooo/ooo-site/trunk/content/udk/common/man/concept/uno_contexts.html Sun Nov 27 22:49:46 2011 @@ -0,0 +1,830 @@ +<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> + + +<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=iso-8859-1"/> +<TITLE> +UNO Contexts +</TITLE> + + + +
 +
 +
 UNO Contexts
 + 	 +  +  +  +
 + +
 + +
 Contents
 + +
Abstract
 +
Introduction to Contexts
 +
Component Context +
 +
Context Interface
 +
Factory Context
 +
Instance Context
 +
 +
Current Context
 +
Extensions to the XML Component Description
 +
Migration path for existing OneInstance services
 +
Things left to do...
 + +
Abstract
 + +
This draft is about UNO contexts; what they are, how and under what condition + they make sense, and when you should use them. UNO contexts are generic + containers for storing arbitrary values that are either used by components + to get their deployment settings or control the runtime behavior of a + component.
 +
Contexts are classified into static (component) contexts and dynamic (current) + contexts. A component context provides a component's deployment values; + a current context provides task-local values, such as values that are transferred + implicitly via a chain of calls excluding other tasks having access to + these values.
 +
The following section, Introduction, + introduces the topic with an example. + The next two sections (Component + Context and Current Context) + present a definition and API proposal for the component and current context + as well as a migration path for the current API.
 +
Finally, the last section proposes Extensions to the XML Component Description, + + component description by describing deployment properties of a component + implementation and invariants. +
 + +
 Introduction
 + +
A component implements a service (defined in UNO-IDL), that is, at + least the defined set of supported + interfaces of the service. The service builds up the contract + between component implementor and component user which is the way a component + can be accessed and used. In general, interfaces abstract from system + and implementation details to allow that a component implementation may + be exchanged for another. Therefore, component users should generally + not rely on a actually running component implementation. This is a desired + feature of components: handle them as isolated as possible. Changing + an interface or in general changing the way a component's functionality + is accessed is difficult, because client code has to be revisited + even for minor changes. + This is not always possible, if, for example, software has been + developed by 3rd party engineers.
 +
 For + further explanations, consider the following example: + A DataService is providing + data in a generic way, abstracting from the specific sources from which it gets + the data. This approach is often chosen in software systems, because + it is a flexible way of extending to unknown data sources, thus avoiding + the need to touch the DataService.
 +
Specific DataProvider components are plugged under + the generic DataService. The user runs the DataService giving a uniform + address for the data he wants to access, not knowing which specific + DataProvider is performing the request. The latter concerns + deployment aspects of actually existing data sources on the machine.
 +
Running the example component on a big machine, you may want to switch + on caching of data to speed up access. Also, in keeping the set of interfaces + small, the service should not directly export an interface like XCache + or have interfaces polluted by caching flags in its access methods. The + set of interfaces and their methods should be kept minimal for extensive + use.
 +
You also don't want to be implementing another set of interfaces + just to support caching functionality. It is even worse if the + DataProviders access further sub-services that should take caching into + account. In the latter case, every calling instance has to manage the + caching settings being propagated to the called instance. Eventually, + not all sub-services support caching functionality, but need + to forward the setting without knowing anything about it.
 +
Last, you want a sensible (thus often different) caching policy being + deployed, if your application is being installed on a small or a big machine. +
 +
Consequences
 +
You want to parameterize a components' implementation, even if it is + accessed indirectly in a somehow weaker way than thru IDL interfaces.
 +
To state clearly: Of course, it is always the best solution to + specify a component + comprehensively by IDL interfaces, but it is also common sense to keep + a service description as minimal (but sufficient) and generic as possible, + and avoid specifics of the underlying system.
 +
This creates a conflict: In general, it is forbidden to use anything + out of a service's implementation that is not part of the service description. + So, by definition, you can only depend (and rely) on the service description. + On the other hand, as stated above, you may want it for convenience and + API design reasons. So there is no silver bullet, for the minority + of cases where one needs a possibility to customize a component's implementation + in a documented way.
 +
Solution Proposal
 +
A convenient (extendable) solution would be, if each component were + granted a set of named properties when it is raised. This is called a + UNO context. It provides deployment data to the component.
 +
Upon raising further component + instances, the set of properties (context) is forwarded. The actually + affected component of a property takes it into account and behaves as + documented (see  + extensions to the XML component description). All other instances, in the + chain of raised components, ignore settings that are unknown to them. So + the modification of a property requires global knowledge about what + components get affected. You have to know if a specific property will + be taken into account, but not necessarily by which component + instance, in general, you don't know what further components are instantiated + when raising a specific component (this is an implementation detail). + The latter point requires a clear documentation scheme of a component's + deployment properties. +
 +
The previous example states the deployment of a component, that is + when the component is installed for example by an application + installation. Enabling or disabling caching, the cache size, et cetera + -- these properties are basically + of a static nature, because the underlying system won't change during execution + of the application. For flexibility, there may be the need to switch it + on or off depending on the current system load. You may do this on a per-instance + basis (customizing a component instance) or per-call basis (customizing for the + current execution only). The latter aspect is clearly of a dynamic nature. + An example usage case may be a low-level socket API, extended by error handling + capabilities without changing the socket API. +
 +
 + To summarize the above:
 +
 +

deployment properties for component implementations,

 +

public definition and documentation of properties (this may include + invariants to test consistent deployment),

 +

implicit propagation of properties when raising further components,
 +

static customization: per component class (deployment) and per instance,

 +

dynamic customization: per call.

 +
 +
All of the mentioned customization of UNO components + is referred to as "UNO contexts". A UNO context delivers additional + runtime information for component execution. UNO contexts provide a set + of named values like a property bag. You can retrieve values by + their names; this is flexible for modifications without changing the + context interface.
 +
There is a distinction between static and dynamic contexts: A static + context + (also referred as the "component context") may be used simultaneously + (e.g. by multiple threads), is immutable, + and is commonly given when a component is instantiated. The component + context is divided into a factory context that is accessible by all instances + of a component and provides persistent values to the component. + In addition, there is the specific component context given at instantiation + time, which was eventually customized by the caller that raised the component + instance. + In contrast, a dynamic context (also referred as the "current context") + is implicitly provided by a calling task (e.g. a calling thread) + to the component.
 +
The previous example sketched again, modifying the DataProvider's + caching behavior on a per-instance basis:
 +
 +  +
 +
The caller prepares a context, putting the caching entry + "DataProvider.CacheOn = true" before raising the DataService.
 +
A subsequently called DataProvider1 recognizes a "DataProvider.CacheOn" + flag. DataProvider2 ignores the caching properties, because it does not + support caching at all.
 +
The caching property is defined as "optional", meaning it need not be + set and the affected component may choose a default behavior if it is + not set. Another attribute for a customization property is "mandatory", + stating that a property must be configured for running a component.
 +
An automatic consistency test for a deployment involves, at least, the testing + of all invariants specified for properties. In general, invariants should + be implemented by the component that uses the involved properties. + Simple invariants may also be specified in the component description of + the implementation, e.g. <invariant type="min" value="128"/>. + For further details, have a look at the extensions + to the XML component description. +
 +
 + In general, the following figure sketches context propagation along to several instances + (single factory context for all components): +  + +
 Component Context
 + +
Component Context Interface
 +
 The +  + component context interface is basically an interface for getting + arbitrary values by their name. A value once retrieved via the context + interface will remain unmodified, which means, you retrieve the same + value by calling it a second time (immutable). Method + getServiceManager() has been added, because the service + manager instance is often needed by component implementations:
 +
 +
 +  +
 +module com { module sun { module star { module uno { + +interface XComponentContext : com::sun::star::uno::XInterface +{ + any getValueByName( [in] string Name ); + com::sun::star::lang::XMultiComponentFactory getServiceManager(); +}; + +}; }; }; }; +
 + 	 +
 +
 +
 The following enumeration shows common values of a static component + context, though not all properties need to be provided. If a component + could not run because of a missing property, it has to throw an exception, + for instance, CannotActivateComponentException.
 +
 +

ServiceManager (context property name="/singletons/com.sun.star.lang.theServiceManager") + : type com.sun.star.lang.XMultiComponentFactory
 + A service manager to create and use further component instances. Every + createInstance[WithContext]() call will provide a distinct instance, no one-instance services + should be provided any longer. This is currently not possibly, because + of existing component implementations.
 +
 + +

TypeDescriptionManager (context property name="/singletons/com.sun.star.reflection.theTypeDescriptionManager") + : type com.sun.star.container.XHierarchicalNameAccess
 + This singleton accesses the type library providing type information for UNO-IDL types +
 +
 + +

AccessController (context property name="/singletons/com.sun.star.security.theAccessController") + : type com.sun.star.security.XAccessController
 + An access controller instance to perform permission checks. + This instance will use the policy singleton object to obtain user permission sets. +
 +
 + +

User Access Policy (context property name="/singletons/com.sun.star.security.thePolicy") + : type com.sun.star.security.XPolicy
 + A user policy object reading from some persistent storage providing user permission sets, such as, permissions granted to a user. +
 +
 + +

Global singleton objects are accessible + by their name which is prepended by /singletons/. This + should further on be used for IDL declared singleton services, for + example,
 +
 +
 +  +
 +module com { module sun { module star { module reflection { + +singleton theTypeDescriptionManager +{ + service TypeDescriptionManager; +}; + +}; }; }; }; +
 + 	 +
 +
 +
declares a context entry + /singletons/com.sun.star.reflection.theTypeDescriptionManager + of an TypeDescriptionManager service object at runtime. It + is part of the deployment that this singleton is available and installed + into the initial factory context at runtime.
 +
This service object will be raised "late" on first use and disposed + when the component context is closed down (i.e. is disposed). By + default, each new component context wrapping an existing one (i.e. + delegating unknown property requests to it) should add itself as event + listener to dispose itself when the previous one is disposed (=> + chaining).
 +
 +
Additional properties of any type may + be provided by the context. + Those properties should be prefixed by /implementations/implementation-name or /services/service-name. + In the latter case, they need to be documented in the service description. +
 +
 +
Factory Context
 +
The factory context of a component is initialized when the system is + started. + Commonly one factory context for all components is read out of a central + configuration database at startup of the service manager. All persistent properties + have to be provided to all factories, because it is in general not + known which component will use a property.
 +
Details about getting up the factory (deployment) context are not + discussed + here, because this involves specific knowledge of the underlying storage + and the way the system is initialized. + Common storage formats + for OpenOffice.org are the applicat.rdb or the OpenOffice.org + Configuration service. +
 +
A common cppuhelper API to bootstrap using a registry database (e.g. the applicat.rdb) + is presented here. + Java support is also implemented. +
 +
Instance Context
 +
The service manager implementation is extended by supporting the + XMultiComponentFactory interface. The factory helpers are + extended by supporting + XSingleComponentFactory + interface, too. + It has to be assured that the factory implementations acknowledge a given + context and + service manager instance at runtime (thus not referencing statically, but + on every createInstanceWithContext() call).
 +
The user is creating a component instance by calling on the + XMultiServiceFactory + (old) or + XMultiComponentFactory + interface:
 + +
 +
 +  +
 +module com { module sun { module star { module lang { + +interface XMultiComponentFactory : com::sun::star::uno::XInterface +{ + com::sun::star::uno::XInterface createInstanceWithContext( + [in] string ServiceSpecifier, + [in] com::sun::star::uno::XComponentContext Context ) + raises (com::sun::star::uno::Exception); + com::sun::star::uno::XInterface createInstanceWithArgumentsAndContext( + [in] string ServiceSpecifier, + [in] sequence< any > Arguments, + [in] com::sun::star::uno::XComponentContext Context ) + raises (com::sun::star::uno::Exception); + sequence< string > getAvailableServiceNames(); +}; + +interface XSingleComponentFactory : com::sun::star::uno::XInterface +{ + com::sun::star::uno::XInterface createInstanceWithContext( + [in] com::sun::star::uno::XComponentContext Context ) + raises (com::sun::star::uno::Exception); + com::sun::star::uno::XInterface createInstanceWithArgumentsAndContext( + [in] sequence< any > Arguments, + [in] com::sun::star::uno::XComponentContext Context ) + raises (com::sun::star::uno::Exception); +}; + +}; }; }; }; +
 + 	 +
 +
 +
 +

The callee of createInstanceWithContext() will + prepare a context with its current one (that it is running on) as + described here: +
 +
 +
 +  +
 +any getValueByName( [in] string Name ) +{ + if (new_properties.hasElement( Name )) + { + return new_properties.getElement( Name ); + } + else + { + return factory_context.getValueByName( Name ); + } +} +
 + 	 +
 +
 +
 +

The component factory's method createInstanceWithContext() + is called with the new context.
 +
 +

The component factory directly instantiates a component + forwarding the context to use.

 +
 +
Backward Compatibility: If the user is calling XMultiServiceFactory::createInstance() + (old), then the service manager's context is provided to XSingleComponentFactory::createInstanceWithContext().
 +
The service manager is the only instance that is used by older component implementations, + thus it is the only instance that knows the context to be propagated to + further component instances (implicitly calling old XSingleServiceFactory::createInstance()). + This is a potential problem, because the only solution for proper context + propagation would be to clone the service manager and install the new context; + although, one-instance component implementation (using static initializers) + will fatally hinder the propagation of the correct context.
 +
For performance reasons, the current stoc service manager implementation does not clone  + the service manager in case of an XSingleComponentFactory::createInstanceWithContext() call. + This means that only directly launched service instances get the correct context. + In most cases, this should be no problem, because all up-to-date component implementations using component context + entries will call on XSingleComponentFactory, from entry-point service + objects to back-end service objects. +
 + + +
 Current Context
 + +
The dynamic context, also known as "Current Context", is bound + to the current execution task. A task denotes not only a process thread + of execution, but the current context of a task remains for dispatched + threads or inter-process invocation threads, for instance, a child + thread inherits its initial current context from its parent thread.
 +
The current context can be accessed via the UNO runtime which is part of + the + language binding specification. + The runtime grants read access to the current context as well as installing + a different context for subsequent callers. + There is + support for C/C++ by the cppu runtime and the Java UNO runtime, although currently the context is not bridged. + The current context's interface is + com.sun.star.uno.XCurrentContext: +
 +
 +
 +  +
 +module com { module sun { module star { module uno { + +interface XCurrentContext : com::sun::star::uno::XInterface +{ + any getValueByName( [in] string Name ); +}; + +}; }; }; }; +
 + 	 +
 +
 + +
It is always recommended to use an interface method to pass parameters, + due to explicit passing and type safety of parameters (caller's and + callee's contract). Though there are very few sensible cases for a current + context, common properties of the context are:
 +
 +

access control restriction ("access-control.restriction") : + type com.sun.star.security.XAccessControlContext
 +
This property provides a task-local access control restriction + taken into account during permission checks. For details, have a look + at the dynamic + restrictions section of the security document.
 +
 +

access control user credentials ("access-control.user-credentials.*")
 +
These properties relate to the calling user, e.g. + access-control.user-credentials.id. For details, have a + look at the dynamic + restrictions section of the security document.
 +
 +

arbitrary values for higher stack levels which occur in an + "optional" manner (could be described as "nice to have if set at the + current context") like callback/ error handlers.
 +
 +
 +
The current context interface reference must not be shared with other + threads. + In general, you should also take care to not share values you got from the + current context with other threads.
 +
When calling across process boundaries, there is a question of what + happens to + the dynamic context. Of course, remote transparency is a wishful feature. + On the other hand, remote access on the context has to be optimized for + performance.
 + + + +
 Extensions to the XML Component Description
 + +
In this section, I propose extensions to the current XML + component description describing deployment properties of a component + implementation and invariants. + Invariants allow testing of a specific deployment, that is, if the specific values + make sense. + All elements appear as sub element of component-description which, now, may + also contain a component-properties element:
 + +
 +
 +  +
 +<!ELEMENT component-description + (author,name,description,loader-name,supported-service+, + component-properties?,(%component-description-optional;)*)> + +<!ELEMENT component-properties property*> +<!ELEMENT property description? invariant*> +<!ATTLIST property name CDATA #REQUIRED + optional (true|false) #IMPLIED + value-type (boolean|string|number) #IMPLIED + default-value CDATA #IMPLIED> + +<!ELEMENT invariant EMPTY> +<!ATTLIST invariant type (valid|invalid|min|max) #REQUIRED + value CDATA #IMPLIED> +
 + 	 +
 +
 + +
Properties are described by their name, + value-type, optional attributes, and a number + of optional invariants. The name denotes the + property's name as it will appear in contexts. The optional + attribute denotes whether the property can optionally + be set in a deployment or is mandatory (i.e. if not set, the component + implementation + cannot run). An optional default-value can also be set. + Invariants follow up as sub elements + to check whether a given property value makes sense. The invariants given + value + must always be convertible to the property's value-type.
 +
Current invariant types have been chosen for the + following strings:
 +
 +
valid -- denotes a valid value of the property overriding all other invariants
 +
invalid -- denotes an invalid value of the property overriding all other invariants except the + valid invariant
 +
min -- denotes a lower boundary for a property number value
 +
max -- denotes a upper boundary for a property number value
 +
 + +
Example:
 +
 +
 +  +
 +... +<component-properties> + <property name="DataProvider1.CacheOn" value-type="boolean"/> + <property name="DataProvider1.CacheSize" value-type="number" default-value="256"> + <invariant type="min" value="128"/> + <invariant type="max" value="512"/> + <description> + Property CacheOn controls whether caching of data should be performed. + Property CacheSize controls the size of the cache. The CacheSize is limited to a range + between 128 and 512. + </description> + </property> +</component-properties> +... +
 + 	 +
 +
 + +
 + Attention: Proposal only! + The previous component description extensions + are yet to be discussed and extended -- and implemented -- + with respect to further tools performing tests. +
 + +
 Migration path for existing OneInstance services
 + +
Formerly, a service decided to be a one instance service by choosing the appropriate factory +( in general cppu::createOneInstanceFactory() ). When the service is first instantiated, +the factory keeps a hard reference to the service. All subsequent createInstance()-calls +return the same object. When the servicemanager got disposed, it disposed all factories, +which released the reference. + +
 The former OneInstance services can be separated into the following categories : + +
 +

Services that have state or instantiate other services.

 +

Services that don't have state and that don't instantiate further + services. + These services are OneInstance for optimization reasons + ( it would be a waste of heap to have multiple instances). + A classical example is the TypeConverter services, which offers simple + conversion functions. +

 +
 + +Each group must be treated differently when moving to the context concept. + +
 +

These are +singletons. +These objects should be placed into the context. +You use a normal factory, so that it is possible to instantiate multiple instances. +You add a singleton entry to the idl-file. All clients, that previously accessed the object +via the servicemanager, must switch to accessing it via a context. This is a required change. +
 +
 If there is not time to make the changes immediately, then stick to the OneInstance +service, as it is currently, and schedule a task force for it. +
 + +
 There may be exceptions, for instance, the javavm service can only be started once per process and + it must not die (because the javavm can not be released once it has been started). + Such conditions should be handled by the component internally, that is, the javavm-service + will hold its self or it will keep a list of the contexts it is used in, and adds itself as + disposing listeners. These exceptions should be really rare ! +
 + +
 Another possibility may be to make it a normal service.
 + +

These services can be reused over all contexts, so a single instance per +process is +desired. These services should use a normal factory, but within the dll-local createInstance() +function, they keep a static weak reference on the object. For every createInstance()-call, +it first checks the weak reference. Otherwise, it instantiates the implementation and assigns +it to the weak reference. +

 +
 + +
 Registry considerations for context-information
 +
The following deployment issues arise when introducing contexts:
 + +
 +

There is need for a place to store the singleton information (i.e. the + name of the service + to be instantiated when a singleton gets accessed the first time).

 +

There is need for a place to store implementation-dependent context settings.

 +
 + +
Singleton
 +
A singleton gets a service-name assigned in an idl-file (which means at +specification time). For example, the com.sun.star.theBridgeFactory-singleton +is assigned to the com.sun.star.bridge.BridgeFactory service and can be +instantiated at runtime using this name.
 +
But the specification in idl is only minimal, the singleton instance must, +at least, support this service. Take a look at the service-manager; +something that we call a service-manager must at least support the + + +com.sun.star.lang.MultiServiceFactory + +service, so this is specified in IDL. However, in OpenOffice.org, we need a + +com.sun.star.lang.RegistryServiceFactory +service, which additionally supports the MultiServiceFactory. +This information can't be retrieved from IDL anymore, it must be defined at +deployment time.
 + +
 +The initial routine, that creates the context, must be able to access the +singleton-information. This information should be provided in an .rdb-file +(the only persistent storage we have on the UDK-level). The following kinds of +information is currently stored in an .rdb-file:
 + +
 +

Types (needed by the typeprovider),

 +

Service registrations (needed by the RegistryServiceManager),
 +

Singleton information (needed by the initial routine that creates the +context).

 +
 + +
I think a good strategy is to have one .rdb-file for each category. This +avoids unnecessary nesting of registries and gives the most flexibility when +multiple processes shall share registries (though it always needs to be taken +into account that a registry can only be opened with write access, when no +other process have read or write access to the same registry). To reflect this, +we should introduce the following bootstrap-variables :
 + +
 +

UNO_TYPESRDB (contains a list of registry-names that contain type information + [read-only-access])

 +

UNO_SERVICESRDB (contains a list of registry-names that contain the registered services + [read-only-access])

 +

UNO_CONTEXTRDB (contains a list of registry-names that contain the singleton-information + [read-only-access])

 +

UNO_SERVICESRDB_RW (contains exactly one registry name where service information + can be written)

 +
 + +Note that you still can have one registry, that holds all information (types,services, and contexts). +This registry would get opened three times, which bears no problem as long as it is +opened for read only. + +
Additional context settings
 +
The context contains (besides singletons) component specific values. This +information +must be available when the context is created, so, it seems a good idea to insert this information +into the above suggested .rdb-file.
 + +
 The registry does not offer to store all possible UNO-types, since it must store the value as +a byte-sequence ( with some routines such as any2Sequence() and sequence2Any() in cppu).
 + +
 There needs to be a command line-tool, that inserts values into a rdb.
 + +
Integration into the build process
 +
There is no comprehensive solution-suggestion currently, so here are listed +some thoughts.
 + +
 +

The singleton-information specified in IDL must be available outside + udkapi/offapi project. This should be delivered as its own .rdb-file + (maybe udk_singleton.rdb).

 +

If we come to the conclusion + that the creation of the service-manager will probably always be hardcoded, it should be + sufficient, currently, for most tools not to have a context .rdb-file.

 +

How do we get a context.rdb for an application? The knowledge on what + should be in the + context.rdb is distributed.
 +
 +
 The component developer wants to give some sensible defaults to context values. +
 At the time the setup for a certain application is built, one wants to insert + only those context values that could be needed in the deployed application. + Here it will be very difficult to avoid redundancies for multiple applications. +
 The setup wants to install only context values for installed components and it + wants to omit other ones. +
 The user/deployer wants to modify or add context values. +
 + +
 + +
Registry limitations
 +
A lot of deployment problems arise from storing information into an +.rdb-file. We definitely need a database in core UNO as soon as possible. +It is planned to use the configuration services for this and to move component +registration into it. This will ease getting overviews about components, +implementations, properties, singletons, location, et cetera. +Registry database files (rdb) are only used for type access.
 +
The coming structure of the configuration (which is read-only accessible via +the component context) will look like this:
 + +

 +/singletons/theFoobar/ + service = Foobar + [arguments = { ... }] +... + +/services/Foobar/ + available-implementations = { FbImpl[, ...] } + uses-implementation = FbImpl + [<arbitrary conceptional properties>] +... + +/implementations/FbImpl/ + supports-services = { Foobar[, ...] } + url = libfoobar.so + activator = com.sun.star.loader.SharedLibrary + [<arbitrary properties>] +... +

 +
 + +(last two sections co-edited by Joerg +Budischewski.)
 + +
Things left to do...
 + +
The following things are left to do:
 + +
 +

[high priority]:  +There is currently no persistent storage for component context values, +singleton object specifications, services, and implementations. This includes +switching service registration to this storage format.
 +
We have to use the configuration services as soon as possible, that is, +bring configuration into UDK.
 +
 +

[mid priority]:  +Supporting XMultiServiceFactory the service manager has to be +revisited. The service manager has to clone itself (changes +DefaultContext property) when a +createInstanceWithContext changes the context of the component to +be raised.
 +
 +

[low priority]:  +The current context is not transferred via the URP-UNO interprocess bridge. +This has to be fixed with no lack of performance.
 +
 +
 +
 +
 + +
 Author:  +Daniel Bölzle
 + Copyright 2001 Sun Microsystems, Inc., 901 San Antonio Road, Palo Alto, CA 94303 USA.</font +
 +	 +
 +
 + + Propchange: incubator/ooo/ooo-site/trunk/content/udk/common/man/concept/uno_contexts.html ------------------------------------------------------------------------------ svn:eol-style = native
|View raw message


text:
? They are about 3ft at the shoulder and weigh an average 135-350lb but can be much more.
? They can run at 35mph.
? There are about 200,000 and are found in most US states.
? Omnivores, they will eat anything, gorging until their stomachs can hold no more.
? Protected in US National Parks, many have lost any fear of man, even begging for handouts at the roadside.
? Wild bears live up to 25 years.
? Advice to humans confronted by one is: stay calm, do not run. Back away slowly, avoid blocking its escape route, pick up children so they don't run or scream, avoid eye contact, talk in a soothing voice.
- More about:
- National Parks

subset: commoncrawl


text:
Category : Alternative Treatments Posted : 25/03/2015 Price : Check with seller
Infertility is the condition of failure to conceive even after many years of unprotected intercourse. Infertility can be caused due to either one partner or both the partners, so both should be evaluated for fertility checkup. Pregnyl 5000 iu HCG is a highly purified preparation that is pyrogen free obtained from pregnant female's urine used to induce ovulation and pregnancy in anovulatory females and in females pre-treated with menotropins. Infertility can be treated with the help of medicines which include tablets and hormonal injections to stimulate ovulation Buy Pregnyl 5000 iu HCG injection online from our online drug portal with great offers of secure and fastest delivery at affordable rates without any doctor's prescription. You can also buy hcg 10000 iu injection online with best price .
Contacts us: email@example.com Los Angeles, California +1 (844) 455 8585 Website: http://www.genericepharmacy.com/buy-ovidac-pregnyl-hcg-5000iu-10000iu-online.html


text:
https://onlinecasinosoffers.com/online-casino-canada/ - canada online casino
Previous Events
Perennia is hosting and organizing a series of four workshops around Nova Scotia in November for small and medium-sized food producers and processors preparing to take a product to market, new to the food processing business or considering value-adding. The main focus of the day-and-a-half workshop is helping participants understand their responsibilities as food producers in the areas of regulations, packaging, labelling and food safety, and how to build successful partnerships with suppliers. Also covered will be how to market and sell your product successfully once it is created, including how to build relationships with retailers and wholesalers, the role of market research, how innovation and incubation can help your product, and how to develop a sales and marketing plan. Funding is being provided by the Atlantic Canada Opportunities Agency. Dates and locations are: November 1-2 (Windsor); November 3-4 (Bridgewater); November 7-8 (Truro); and November 9-10 (Sydney).
Here is more information, the dates, the agenda and how to register
Dear AFBPA Members & Industry Partners;
Please accept our invitation to join us in Shippagan for the upcoming Acadian Peninsula Food Processing Conference. The Conference Agenda commences June 23rd at 9 am. Doors open at 8:30 am. All details are in the attached PDF. Registration is online at http://icidici.com/atlanticfood or at the door.
Full event: includes presentations, reception luncheons & banquet
Please note that simultaneous translation will be available throughout the Conference!
Truro, NS
The Atlantic Food & Beverage Processors Association is pleased to offer this timely and relevant program, to be delivered by SAI Global. This two-day course will help participants recognize situations that may carry a risk for intentional food contamination and develop effective preventative approach to assess and avoid those risks.
*Please note - space is limited so early registration is recommended. First come, first served.
MonctonNovember 23-24, 2015Trainer: Jim Chance


text:
LG's current portfolio of smartphones isn't that big, yet the company still struggles to keep even its flagships updated to the latest Android version. Take the G4 for example. The company announced Marshmallow would begin seeding to the device way back in October in Poland, but it took a lot longer to graduate to full roll-out. Sprint had it in December, US Cellular in January, while AT&T, T-Mobile, Verizon, and the international variants got it in February. That was a gruesome wait, but it doesn't even compare to the LG V10.
We're just now hearing about the first instance of an OTA update rolling to the V10, and that's hitting the international variant for users in Turkey.Read More


text:
SailNet Community (http://www.sailnet.com/forums/)
- Gear & Maintenance (http://www.sailnet.com/forums/gear-maintenance/)
- - Vendor Kudos (http://www.sailnet.com/forums/gear-maintenance/64691-vendor-kudos.html)
Vendor Kudos
Not sure if this is the right board to post this, but for anyone in the Long Island Sound area, I just wanted to give a reccomendation for Seafarer Canvas for custom boat canvas, interiors and upholstery.
they just completed a bimini installation for me. custom fit to work around the various issues common to sailboats like hatches, winches, and running rigging. The frame was built entirly out of stainless steel and has no pesky straps to get in the way of winch handles or bodies trying to go forward in a hurry, as well as installed everything.
All for about $75 more than the aluminum frame bimini's that you can order online that you need pay an arm and a leg to ship, then to tweak to fit it for your boat while you spend hours installing it yourself.
very happy with them, strongly reccomend.
ps. tried to attach pics, but upload fails even after I shrunk them down to under 800x600 size.
I don't know what the problem is, but you could set up a photo album on SailNet, upload the photos to the album and then post a link to them.
640 x 480 small file.
Thanks for the tip!
uploaded here
Nice - that is a very similar design to the one we made ourselves for our boat, although I designed ours to attach only to the pushpit so no need to drill any new holes. After we finished the project we questioned how we ever used the boat in July and August for two seasons without one. I like that you had them set it up to accept additional panels down the road.
|All times are GMT -4. The time now is 10:09 PM.
Powered by vBulletin® Version 3.8.7
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
vBulletin Security provided by vBSecurity v2.2.2 (Pro) - vBulletin Mods & Addons Copyright © 2017 DragonByte Technologies Ltd.
User Alert System provided by Advanced User Tagging v3.1.0 (Pro) - vBulletin Mods & Addons Copyright © 2017 DragonByte Technologies Ltd.
(c) Marine.com LLC 2000-2012


text:
Hrishikesh Bharadwaj
Hrishikesh Bharadwaj (15 th july 2002 / Bangalore)
Poems by Hrishikesh Bharadwaj : 14 / 16
To The Dodo - Poem by Hrishikesh Bharadwaj
To a canopy of lush green,
To an inquisitive land of breeze.
To a score of gleaming stars
To the happy ingenutive Dodo!
To the shrills of the crickets
T the land amidst the seas.
To the flapping sound of leaves
To the merry ingenutive Dodo!
To the shaggy wet damp floor
To the loam so cold and low.
To the stems of juicy berries
To the jolly ingenutive Dodo!
Topic(s) of this poem: Nature
Poems by Hrishikesh Bharadwaj : 14 / 16
Poet's Notes about The Poem
The poem themes on the nature, the canary island where the now extinct bird Dodo dwelled. The trees, the island and sounds heard there are contrasted using British English and poetic devices
Comments about To The Dodo by Hrishikesh Bharadwaj
Read this poem in other languages
This poem has not been translated into any other language yet.
I would like to translate this poem »
Poem Submitted: Thursday, July 31, 2014
Poem Edited: Saturday, August 2, 2014
Hrishikesh Bharadwaj's Other Poems
Famous Poems
Phenomenal Woman
Maya Angelou
Still I Rise
Maya Angelou
The Road Not Taken
Robert Frost
If You Forget Me
Pablo Neruda
Langston Hughes
Annabel Lee
Edgar Allan Poe
Caged Bird
Maya Angelou
Rudyard Kipling
Stopping By Woods On A Snowy Evening
Robert Frost
A Dream Within A Dream
Edgar Allan Poe


text:
BALTIMORE -- The bases were loaded with two outs in the 10th inning when Jay Gibbons brought his bat and a positive attitude to the plate against Kansas City right-hander Jason Standridge.
Two innings earlier, Gibbons fouled out with two on and two outs. It wasn't the first time this season he stranded runners on base late in the game, and the last thing he needed was to botch another opportunity.
Gibbons delivered, driving in the winning run with a single to give the Baltimore Orioles a 2-1 victory Thursday night.
Asked in the jubilant clubhouse if he felt redemption for failing to deliver in the eighth, Gibbons replied, "I did fail. Thanks for bringing that up. I was trying not to think about that in the 10th. It's just been kind of a rough start. I've had a lot of situations like that and didn't come through, so it felt good to hit that ball in play."
Only 13,229 showed up on a chilly night, the second-smallest crowd in the 16-year history of Camden Yards. Kansas City entered in last place in the AL Central; Baltimore owned the same spot in the AL East.
Brian Roberts led off the 10th with a double and took third on a bunt by Melvin Mora. After Nick Markakis and Miguel Tejada received intentional walks from Standridge (0-1), Aubrey Huff hit into a forceout at the plate before Gibbons recorded his third hit of the game, an opposite-field liner to left.
Chris Ray (1-1) worked a perfect 10th to earn the win.
Kansas City starter Gil Meche left with a mild right hamstring strain after blanking the Orioles on seven hits over six innings. That, more than the defeat, bothered Royals manager Buddy Bell.
"There's a couple reasons why it's disappointing. We lost, but we're not quite sure what's going on with Gil right now," Bell said. "His hamstring, we're anxious to see where that is. We think it's fairly mild, but we'll get a better diagnosis (Friday)."
Meche said he felt a twinge while throwing a sixth-inning curveball to Huff, who struck out and ended the inning.
"I just felt a little stiff. It's very unfamiliar to me," said Meche, who agreed to a $55 million, five-year contract in December. "I've never had anything to do with my hamstrings, ever. I was making good pitches for the most part. I just couldn't risk going back out there and maybe doing some bad damage to it."
Meche left with a 1-0 lead, and the bullpen gave up the advantage as soon as he left.
Gibbons hit a leadoff single off Jimmy Gobble in the seventh, and Kevin Millar followed with a liner in the gap in left-center. Esteban German retrieved the ball and threw it to shortstop Tony Pena, who cut down Gibbons with a solid throw to the plate.
After Corey Patterson hit a popup, Paul Bako looped an opposite-field double about 15 feet beyond the infield and just inside the foul line, scoring Millar with the tying run.
Baltimore got runners on the corners with two outs in the eighth against Joel Peralta before Gibbons fouled out.
But Gibbons made amends in the 10th.
"When you keep failing it's hard not to press," Gibbons said, "but I had a good swing my at-bat before and I just went up there with the same approach."
Steve Trachsel gave up one run and three hits in seven innings, but couldn't get enough support to earn his first win with Baltimore. Trachsel, who has a 2.63 ERA in two starts, kept Kansas City hitless until Ross Gload led off the fifth with a bloop single to center.
John Buck opened the sixth with the Royals' second hit, a double. He remained there until Mark Grudzielanek blooped a two-out RBI single for a 1-0 lead.
It was the seventh consecutive game in which an Orioles starter allowed three runs or fewer; Baltimore is 4-3 over that span. The Orioles had 12 hits but struck out six times -- including three by Huff -- and bounced into three double plays.
Baltimore got two runners on in the first, third and fourth innings but failed to score.
- The Orioles put RHP Jaret Wright on the 15-day DL and recalled LHP Brian Burres. Jeremy Guthrie is expected to start Sunday in place of Wright, who hopes to return by the end of the month.
- KC's Mark Teahen went 0-for-4 and is mired in an 0-for-15 skid.
- Gibbons went 2-for-3 against Meche and is 7-for-20 (.350) against the right-hander.


text:
Monongalia County Master Gardeners
General Information
The Monongalia County Master Gardeners were organized in November 1997. The first class of Master Gardeners completed their training classes in March 1998 then met to organize and formulate a direction for their volunteer activities and other ways they could share their experience with the public. They set the course for the Master Gardener classes yet to come. We are celebrating more than 15 years in Monongalia County!
The Master Gardener Program was created by university Extension services to meet the enormous increase in requests from home gardeners for horticultural information. The first Master Gardener Program was started in 1972 in Washington State. Since then, the program has spread to 48 states including West Virginia.
To become a Certified Master Gardener and a member of the Monongalia County Master Gardener Organization, a person must successfully complete 40 hours of classroom education and then give 40 hours of approved volunteer work to their community within one year of completing the classroom work. In order to retain Certified Master Gardener status, a person must complete 10 hours of educational classes and 20 hours of volunteer hours on a yearly basis thereafter. For further information, contact the Monongalia County Extension Office at 304/291-7201 or Email Sheryl Bergen Jarvis.
Meetings and Programs
Business meetings are held the first Wednesday of each month at 6:00 p.m. contact the extension office at 304/291-7201 or Email for meeting location and speaker information. The education meetings are open to the public.
Additional questions? Contact Sheryl Bergen Jarvis at 304-291-7201 or email
Mason Dixon Park
Officers and Executive Board – 2016-17
|Rod Brundage
|Dianne DeAngelis
|Nancy Ulrich
|Darlene Davisson
|Sheryl Bergen Jarvis
|Newsletter Editor
|Sheryl Bergen Jarvis
|Past President
|Linda Watkins


text:
|<< Previous book
|Next book >>
Scavenger Hunt(2015)
(The fourth book in the Aylesford Place series)
A novel by Steve Demaree
Humor and touching moments abound in this fourth installment in this series about a neighborhood that everyone describes as the neighborhood in which they would like to live. That might be because of or in spite of the quirky characters who live there. This time a scavenger hunt and a surprise gift to everyone from the street's wealthiest neighbor replace the pink flamingo, older adults shooting paintball guns, and croquet in the snow of the first three books. But once again well-known and little-known holidays are celebrated by all, creating a delightful time for characters and readers alike.
Similar Books by other authors...
When a Heart Stops
(Deadly Reunions, book 2)
Lynette Eason
Shackled Lily
(Winsor, book 2)
T L Gray
Love Makes a House a Home
(Home to Collingsworth, book 3)
Kimberly Rae Jordan
The Long Road Home
(Home to Collingsworth, book 4)
Kimberly Rae Jordan
Used availability for Steve Demaree's Scavenger Hunt
See all available used copies of this book at Abebooks UK or Abebooks US
Kindle Editions
November 2015 : USA, Canada, UK Kindle edition
|Title: Scavenger Hunt (Book 4 Aylesford Place Series) (Aylesford Place Humorous Christian Romance Series)
Author(s): Steve Demaree
Availability: Amazon Amazon UK Amazon CA
Genre Pages


text:
Need a CRP Blood Test in Warren, CT? Simply order online 24/7 and get a fast, affordable CRP Blood Test at a lab near you (Find More Locations):
11 Oak Park LnP: (888) 946-9522
New Milford CT 06776
M-F, 8:00am - 4:00pm
Why would I get a CRP Blood Test?
A CRP Blood Test is a blood test that checks the CRP level. People in Warren, CT get a CRP Blood Test at the request of a medical provider or for general tracking.
How much does a CRP Blood Test cost?
Our CRP Blood Test price includes the doctor's order that you need to get tested in Warren, CT, all lab fees and taxes, and a pdf copy of your results. For current prices, CLICK HERE.
What does a CRP Blood Test report look like?
For a CRP Blood Test sample report, please CLICK HERE.
We are delighted to offer the CRP Blood Test in Warren, CT.


text:
On Overcome Food Intolerances you will learn everything you need to decide whether you have a food allergy or an intolerance. Learn how to recognize the symptoms, get an accurate diagnosis and learn about the different treatments that are available.
Importantly you will learn how to lessen the negative impact that food sensitivities can have on your health and life.
As new treatments become available we tell you about them.
What do you need to know about living with food intolerance?
Before we tell you about what is already on the site and how best to find what you are looking for I would like to ask a favor of all of you. Don't worry it is not a big favor and it won't take long.
Please use the comments box to answer these questions for me.
What do you want to/need to know about food sensitivities and coping with them?
How is food sensitivity affecting your life, what issues to you need solved?
In other words … What information would you like to see added to this site?
Tell me what you need and I will do the research to give you the information and resources you need to live your life with food sensitivities.
How to Quickly Find What you Need on Overcome Food Intolerances
What You Will Find on This Page
- How to Quickly Find What you Need on Overcome Food Intolerances
- Gluten Intolerance
- Wheat Intolerance
- Egg Intolerance
To help you to find the information you need this website is organised primarily by food sensitivity type.
For example, if you suspect (or know) that you have a wheat intolerance all you need to do is to click on the 'wheat; tab in the top menu. For gluten click that tab. If you want general information it is the FI Overview tab you need.
For each food intolerance click the menu to be taken to the complete guide for that food allergy.
Clicking the main menu takes you to a detailed article that tells you the basics, what causes that particular food insensitivity, the symptoms, treatments and how to avoid foods that contain allergens.
From that page you can navigate to other articles. These go into more depth, such as how to get tested for that intolerance. In addition, there are links on the left hand of the page to help you to navigate to the other articles.
You will also find general articles, news and tips for living with food sensitivities under the blog tab.
Please take the time to look around. If you find the information helpful please share it with others. There are social media buttons on each page to help you to do that.
If you feel there is something missing please let me know and I will add it at a later date.
Here is an index of the main areas of the website to help you even more with navigation.
SITE INDEX and OVERVIEW
Food Intolerances General Articles
This section covers the subject of food sensitivity in general. It is a good place to get an understanding of the subject .
You will find this article about food allergy apps and software particularly useful.
Lactose Intolerance
As soon as I find the time to writhe these pages you will be able to learn all about living with lactose sensitivity.
If you suspect that you are suffering from lactose intolerance, I highly recommend your visiting this website. The owner of this site provides excellent recipes, and takes a very hands on approach to helping people who are suffering from lactose intolerance.
Dairy and Milk Intolerance
Many people think that dairy intolerance is the same as lactose intolerance. This is an understandable assumption, but it is usually wrong to assume that because you cannot drink milk that you are also lactose intolerant. You will understand the issue far better by reading this article.
If you already know that you are dairy or milk intolerant, my suggestion would be that you visit this website. This site will help you to go dairy free, if you need to.
How to live a dairy and milk free life. (coming in the future)
Gluten Intolerance
These pages include helpful content, including:
How to avoid eating gluten and still enjoy a varied diet
How to deal with celiac hair loss
Wheat Intolerance
Living without wheat in your diet, but being able to enjoy allergen free bread, pasta and baked goods.
Yeast Intolerance
Unfortunately, I have not found the time to write this section, but in the future I plan to explain how to cope with yeast intolerance and eat a yeast free diet. It is not a subject that is widely covered, but you can find out important things like which foods to avoid if you are yeast intolerant, from this website.
Egg Intolerance
Eating a balanced and varied diet even if you cannot eat eggs.
Here are some of our readers favorite egg free pages:
learn about egg intolerance symptoms here
Other Food Sensitivities
This area of Overcome Food Intolerances covers other, less common food sensitivities. There is less detail here, because these food allergies and sensitivities are less relatively rare, but there are plenty of links out to sites that specialize in each of these conditions.
Included are:
Unfortunately, due to time constraints I am yet to write a complete overview of each of these food intolerances, but plan to do so in the future.
Sugar Intolerance
In the meantime this website gives you a good idea of what you need to know. This lady shows you how to go 100% sugar free. Following her advice will help you to mange both sucrose intolerance and sugar or fructose malabsorption, which are the two main forms of sugar intolerance or sensitivity.
Soy Intolerance
If you cannot eat soya products you are in for a nasty shock because soy beans are used in a huge range of other products. You really, really need to know what you are doing if you are sensitive to soy. Fortunately, this guy knows what he is talking about, and can help you to live a soy free life, and start to feel better. Just click this link to get high quality help fast.
Nut Intolerance
Most people have heard of peanut allergies. This is because every year thousands of people who are allergic to peanuts die after eating them. However, what is less well understood is what is known as tree nut intolerance or allergy. Peanuts grow underground, but other nuts like almonds, Brazil nuts grow above ground. People are rarely allergic to these nuts, but an awful lot of people are intolerant of them.
Whilst tree nut intolerance is a relatively rare food intolerance, living with it is not easy. This is because a lot of foods contain hidden sources of almonds, walnuts, and other tree nuts.
If you want to find out more about living with tree nut allergies, this is the site for you.
Just a quick mention while I think of it. Usually if you are allergic to peanuts, that 's it you cannot eat them full stop. Doing so would literally risk your life. However, there are a handful of people out there who are peanut intolerant rather than totally allergic to them. If suspect you are one of those people you really should still eliminate them from your diet, and seek help from an allergist.
Shellfish Intolerance
There is not a huge amount of information out there about shellfish sensitivity, but this page tells you the basics.
Fish Intolerance
Not being able to eat certain fish is also relatively rare. Often it is limited to an adverse reaction to one or two types of fish, for example salmon. Often this type of food intolerance turns out to actually be a histamine intolerance (see below). If you think you have a fish allergy or intolerance, I would strongly recommend your reading this page.
Amine Intolerance
This is a relatively rare problem, but it has a big impact on your life. People who suffer from this food intolerance can have emotional and mental health problems. They can be quick to anger, and a bit on the aggressive side, so recognizing and dealing with an amine intolerance is important. By clicking the link you can learn more about this food sensitivity, which is also known as salicylate intolerance.
Histamine Intolerance
Histamine intolerance used to be little understood. Today, that is no longer the case. There is lot of research going on that is helping people to understand this increasingly common food intolerance, you can read all bout it here.
This section contains mainly guest posts written by professionals who work in the field of food intolerance, sensitivity and food allergies. In this section, I also share articles written by sufferers who share how they cope and details of their facebook pages, websites and books. Occasionally, I also feature reviews of the latest food intolerance tests, diets and food.
If you are interested in contributing to the blog section of this website, please just click the link, and follow the instructions you find there.
Favorite Pages on this site
To visit the best pages on this site use the links below. These will take you to the most visited pages on the site, the ones people turn to the most often:


text:
Yet an accumulation of incidents is beginning to make me wonder whether the public service ethos of the BBC is less pervasive than it appears. For example there is the recent decision to move daily coverage of Parliament into what Gerald Kaufman has aptly called "the ghetto of long wave radio".
According to a leaked report, an edition of The Rantzen Report is due to be criticised later this week by the Broadcasting Standards Commission as "inaccurate, misleading and unfair". And now we are arguing about whether fly-on-the-wall documentaries are sometimes faked. As far as the BBC's The Driving School is concerned, a spokesman said: "Some of it was faked. It was a light-hearted documentary. But the integrity was still there". Is this possible: fake and integrity in the same product?
Of all the many things which comprise public service broadcasting, reporting Parliament is not the least important, particularly as newspapers, regrettably, have substantially reduced their coverage. Is Yesterday in Parliament intrinsically dull? I don't think it is, though doubtless an inspired editor could still improve it. The raw material is more than adequate for the making a good programme.
So far as criticism of The Rantzen Report's allegations about a hospital are concerned, I am less bothered about the rights and wrongs of the case than I am about the BBC's own investigation into complaints about the programme. The Complaints Unit found "minor inaccuracies" and "clear unfairness". None-the-less, no apology was made. As a result, if the Broadcasting Standards Commission does indeed make trenchant criticisms, we shall be left wondering whether the BBC's internal inquiries are more concerned with shielding the corporation than rectifying errors.
However I think that the BBC's stars, seeing a steady trickle of such incidents, take aim at the wrong target. The other day Kate Adie, like many others, put the blame on management style. She says that the BBC has developed a huge division between the people who run the corporation and those who make the programmes. She went on: "It has become more acute in the past decade at the BBC because there is undoubtedly now a management which is a reflection of modern business methods." Certainly there is a curious management-speak, of which Ms Adie says she is ashamed. I saw a BBC recruitment advertisement recently which referred to all 500 qualified accounting staff as being "members of the Finance family".
The fact is that the division which Kate Adie describes exists in most institutions. There is always a gulf of understanding and temperament between the creators of a product and those concerned with administration. The Royal Opera House has provided eloquent evidence of this fissure. Probably, to take a completely different example, the people designing aircraft engines at Rolls-Royce feel similarly frustrated. It is an inevitable tension which is by no means always damaging.
Of course the BBC very well understands the public interest. A paper, "The BBC's Ten year Vision", predicts that the burgeoning commercial sector will increasingly gravitate towards a narrow range of programmes, favouring light entertainment, long-running serials, sport and niche services, despite having a greater number of channels. In contrast, the paper argues, the job of the public service broadcaster in these circumstances is to serve the whole audience, not just those parts which are commercially attractive, to make programmes which the market will never provide and, by setting standards and taking risks, limit any tendency among commercial broadcasters to focus on the lowest common denominator. In other words, the BBC is to be the sheet anchor of the broadcasting system.
That is all very well. But it is not the only matter weighing on the corporate mind. From the outside, the BBC appears as the most fortunately placed corporation in the country. It knows exactly what its revenue will be this year, next year and the year afterwards. Whether it performs badly or not, the licence fee will continue to roll in. Added to which, it has dominating shares of most of its markets. By contrast, Rupert Murdoch's operation looks as dangerous as trying to fly non-stop round the world by balloon. But that is not how the future is seen within the citadel. The BBC's nightmare is that one day it might lose the licence fee or see its value drastically reduced. As it is, the BBC can see that the licence fee is unlikely to grow as quickly as its rivals' advertising revenues or the fees from subscription and pay-TV. That is why the corporation has to hack away at its cost structure, and the result is that Ms Adie feels herself dominated by management types.
As it celebrates its 75th anniversary, the Corporation feels itself on the retreat. For its first 50 years it maintained its market shares at 100 per cent. Then in the 1950s, it lost its television monopoly, in the 1970s competitors came into local radio and finally in the 1990s the monopoly of national radio went. As a result, considerations of public service are not always, or even generally, the main focus.
The BBC is just as concerned as any commercial broadcaster with attracting the largest possible audience. It does not see how it can continue to justify the licence fee without providing popular services which most people want to watch. If the market generally is dumbing down, then the BBC will dumb down. If the most entertaining fly-on-the-wall documentaries require a little contriving or a bit of cheating, then that is what will be done. If parliamentary news appears boring, then it can no longer be allowed to occupy a prominent position.
The corporation then, is subject to two commandments which are often in competition with each other - secure the public interest, and keep up the numbers. This is where the dangerous tension lies, rather than between managers and creative people. Actually the numbers are looking good. In spite of cable and satellite, BBC television's share of all viewing has held steady at around 42 per cent to 43 per cent.
This is the task for the governors. In the annual report, these distinguished people outline a range of duties which they have assumed. To me, their job is simply described. It is to arbitrate between management's understandable desire to retain high market shares in the various broadcasting markets the BBC serves and the requirements of public service, relatively unpopular as these may sometimes be. Chris Smith, the Secretary of State for Culture, has quickly grasped the danger. He said last month that he wanted to establish formal meetings with the governors at least twice a year so that he could ensure that the corporation was sticking to the terms of its Royal Charter. "If it is forgetting that it is a public service broadcaster, then it is forgetting its raison d'etre," he said. Exactly.
- More about:
- Journalism
- Radio
- Television


text:
Two Hands Bella's Garden Shiraz 2010
Winemaker Notes
Black to the core, with a magenta rim. This wine has aromas of cherries, plums, chocolate, cedar, spice and scorched earth. Very seductive. Dense plums explode onto the palate with spice, subtle chocolate and tar. The fine tannin backbone rolls on and on from the mid palate, surrounded by fresh juiciness, dark fruit and subtle oak.
Critical Acclaim
Deep garnet-purple colored, the 2010 Bella's Garden is profoundly scented of blackberries, warm black plums and mulberries with an underlying earthiness plus hints of cinnamon stick, licorice and toast. Rich, ripe and concentrated on the full bodied palate, it is beautifully poised in the mouth with a medium level very fine tannins and crisp acid line framing the dense flesh and going into a long multi-layered finish.
Pepper, clove and plum flavors weave through dense dark cherry and roasted plum fruit, melding together smoothly on the complex and expansive finish. A big wine with depth and harmony. Best from 2013 through 2020.
Glass-staining purple. Intense aromas of black and blue fruit preserves, incense and violets. Lush, palate-coating blueberry and cassis flavors show both power and verve, with peppery spices adding bite. Finishes sweet, floral and very long, with impressive precision.


text:
49,010pages onAdd New Page
this wiki
this wiki
Urad was a Cardassian male and follower of the Oralian Way.
In 2328, Urad was retrieving food for the Oralian camp outside Korto when he was attacked and killed by Cardassian soldiers disguised as dock workers at the port. (TLE - Terok Nor novel: Day of the Vipers)


text: HI Im Evie and i like to write poems and sometimes i like to write song lyrics. I am about to attend Worthing College and i am going to study Graphic Design, Media, English Language and Ict, if i do well in these subjects i hope to go into the advertising business or become a journalist, I have to brothers 1 older and 1 younger and i live with my Grandparents, I have a best friend who is always there for me and never lets me down. She is a little bit of a smartass which is what i like about her and pink hair.


text:
|Additional Information
|The Indian Economy
|Spine Width
|Out Of Stock
Supplemental materials are not guaranteed for used textbooks or rentals (access codes, DVDs, CDs, workbooks).
The Indian Economy
Author: Ray
In this lively, opinionated, and informative piece of writing, Dr. S.K. Ray applies his characteristic and accessible style to all vital sectors of the Indian economy to present a compact, well-researched, comprehensive, and up-to-date treatise on the subject. He has consistently marshalled facts and figures and brought them to bear on todays problems of economic developments and their management. The book covers an extensive portfolio of absorbing topics, all in their varied aspects and manifestations. Written with clarity, this book is a unique attempt to analyze, in considerable depth, various facets of socioeconomic growth such as natural resources, population, agriculture, industry, transport and energy. Besides, the issues like economic planning, land and tenancy reforms, economic reforms, inflation, banking structure, international trade and finance, labour policy, industrial monetary system, science and technology, and the atrophies ailing the economy have also been probed. In a nutshell the book skilfully interprets the economy of todays India to identify her role not only in the development of its own economy but also in relation to the rest of the world. It also identifies the issues, problems and programmes required for the formulation of a strategy for economic growth. The book, a refreshing and significant contribution to Indian economic thinking, will also serve as a valuable textbook for undergraduate and postgraduate students in Commerce and Economics. In addition, it can be of immense help to students appearing in civil services and allied examinations. This brilliant exposition of the Indian economy will also be useful as an important source of reference for scholars, faculty members, administrators, and policymakeTable of ContentsForeword. Preface. Acknowledgements. SECTION 1: BACKDROP1. India: The Economic Dimension. 2. Emergence of Indian Economic Thinking. 3. Natural Resources. 4. Earth and Water. SECTION 2: POPULATION5. The Teeming Billion. SECTION 3: AGRICULTURE6. Agriculture: Overview and Productivity. 7. Hunger and Food. 8. Green Revolution: How Green. 9. Planning for an Evergreen Revolution. SECTION 4: LAND REFORMS AND RURAL ECONOMY10. Land and Tenancy Reforms. 11. Rural Indebtedness, Rural Credit and Gramin Banks. SECTION 5: TRANSPORTATION12. Transport Planning and Coordination. SECTION 6: ECONOMIC PLANNING13. Economic Planning: A Strategy for Growth. 14. From First to Ninth Five-Year Plans. 15. Tenth Five-Year Plan. 16. Planning Experience in Developing Countries Like India. SECTION 7: INDUSTRIAL POLICY17. Monopoly, Managing Agency, Multinationals and Nationalization. 18. Industrial Policy and Economic Reforms. 19. Labour Force, Labour Policy and Trade Unions. SECTION 8: INDUSTRIAL SECTORS20. The Public Sector: Emergence and Evolution. 21. Disinvestment in Public Sector. 22. The Sprawling Private Sector. 23. The Embryonic Joint Sector. SECTION 9: INDUSTRY24. Major Manufacturing Industries. 25. Coal and Other Minerals, Oil and Energy. 26. Small Enterprises Sector. SECTION 10: INDUSTRIAL FINANCE AND INVESTMENT27. Industrial and Institutional Finance. 28. Investment Planning. SECTION 11: SCIENCE AND TECHNOLOGY29. Transport and Technology. 30. Science and Technology for Industrial Development. 31. The Great Indian Information Highway. 32. Investment in R&D on Science and Technology. SECTION 12: CURRENCY, EXCHANGE AND BANKING33. Currency and Exchange. 34. The Reserve Bank of India. 35. Commercial Banking. SECTION 13: PUBLIC FINANCE36. Public Finance and Public Debt. SECTION 14: INFLATION37. Inflation, Price Spiral and India. SECTION 15: INTERNATIONAL TRADE AND FINANCE38. Foreign Trade and Balance of Payments. 39. Foreign Debt and International Finance. SECTION 16: INDIA AND THE WORLD40. IMF, The World Bank and Affiliates, and ADB. 41. India, European Union, ASEAN and SAARC. 42. Outsourcing and India. SECTION 17: ATROPHY43. The Indian Black Market. 44. The Parallel Economy and Cyber Crimes. 45. Corruption in the Economy. Bibliography. Index.