Owner's manual

Manuals Brands Apple Manuals Software WebObjects 3.5

WEBOBJECTS

DEVELOPER’S GUIDE

Summary of content (218 pages)

PAGE 1

WEBOBJECTS DEVELOPER’S GUIDE
PAGE 2

Apple,NeXT, and the publishers have tried to make the information contained in this manual as accurate and reliable as possible, but assume no responsibility for errors or omissions. They disclaim any warranty of any kind, whether express or implied, as to any matter whatsoever relating to this manual, including without limitation the merchantability or ﬁtness for any particular purpose.
PAGE 3

Contents
PAGE 4
PAGE 5

Table of Contents Introduction 9 Common Methods 41 About This Book 11 Other Useful Documentation 12 Action Methods 43 Initialization and Deallocation Methods 46 The Structures of init and awake 46 Part I WebObjects Essentials Application Initialization 47 Session Initialization 48 What Is a WebObjects Application? 17 The Ingredients of a WebObjects Application 19 Components 20 Template 21 Code or Script File 21 Bindings 22 Application Code 23 Session Code 23 A Note on WebObjects Classes 23 Applicatio
PAGE 6

How WebObjects Works—A Class Perspective 72 Starting the Request-Response Loop 72 Taking Values From the Request 73 Accessing the Session 74 Creating or Restoring the Request Page 76 Assigning Input Values 78 Invoking an Action 79 Generating the Response 80 How HTML Pages Are Generated 82 Component Templates 82 Associations and the Current Component 84 Associations and Client-Side Java Components 85 Subcomponents and Component References 86 Part II Special Tasks Creating Reusable Components 91 Beneﬁts o
PAGE 7

Part III WebScript The WebScript Language 163 Objects in WebScript 165 WebScript Language Elements 166 Variables 166 Variables and Scope 167 Assigning Values to Variables 168 Methods 170 Invoking Methods 171 Accessor Methods 171 Sending a Message to a Class 172 Creating Instances of Classes 173 Working With Strings 191 Commonly Used String Methods 192 Creating Strings 192 Combining and Dividing Strings 193 Comparing Strings 194 Converting String Contents 194 Modifying Strings 195 Storing Strings 195 Worki
PAGE 8
PAGE 9

Introduction
PAGE 10
PAGE 11

WebObjects is an object-oriented environment for developing and deploying World Wide Web applications. A WebObjects application runs on a server machine, receives requests from a user’s web browser on a client machine, dynamically generates the appropriate HTML page in response to those requests, and returns that page to the user. WebObjects provides you with a web application server, prebuilt application components, and a suite of tools for rapid development of World Wide Web applications.
PAGE 12

Introduction client-side Java components that behave like dynamic elements, and how to design an application for deployment and improved performance. • Part 3, “WebScript,” is for programmers who want to use a scripting language. WebScript is a scripting language provided with WebObjects for rapid application development. Use of WebScript is entirely voluntary—you can write applications using Java or Objective-C if you prefer.
PAGE 13

Other Useful Documentation • WebObjects Tools and Techniques describes the development tools WebObjects Builder and Project Builder and shows how to use them to create WebObjects applications. • Serving WebObjects describes how to administer and deploy WebObjects applications after you’ve written them. • The WebObjects Class Reference provides a complete reference to the classes in the WebObjects framework. Reference material is provided for both the Java and Objective-C languages.
PAGE 14
PAGE 15

WEBOBJECTS ESSENTIALS
PAGE 16
PAGE 17

Chapter 1 What Is a WebObjects Application?
PAGE 18
PAGE 19

WebObjects is a product that makes it easy for you to write dynamic webbased applications (or WebObjects applications). Before you start programming, however, you need to understand what a WebObjects application is. This chapter answers the question what is a WebObjects application in two ways: ﬁrst by showing you the pieces of a simple WebObjects application, and then by explaining what happens when a WebObjects application runs.
PAGE 20

Chapter 1 What Is a WebObjects Application? The following sections describe the WebObjects application ingredients in more detail. Components To write a WebObjects application, you create components and then connect them. A component is a web page, or a portion of one, that has both content and behavior. Usually a component represents an entire page, so the word “page” is used interchangeably with the word “component.” However, remember, that not all components represent an entire page.
PAGE 21

The Ingredients of a WebObjects Application ﬁles. A component may not need a code ﬁle at all; it may need only a template ﬁle and a declarations ﬁle. Another component might have a code ﬁle but no template ﬁle or declarations ﬁle. Plus, if you create a component using Project Builder or WebObjects Builder, you’ll get a fourth ﬁle, Component.api, which contains API that should be made public to other components. The next three sections describe more completely these template, code, and declarations ﬁles.
PAGE 22

Chapter 1 What Is a WebObjects Application? as shown in Figure 2. (In Project Builder, Java and Objective-C code ﬁles are shown under Classes instead of with the component under Web Components.) HelloWorld Main.wo Main.html Figure 2. Main.java Main.wod Location of Code File for Java Component You can mix languages. It’s common to use WebScript to write your interface logic (that is, the ﬁles described in this chapter) and use Java or Objective-C to write your business logic.
PAGE 23

The Ingredients of a WebObjects Application Application Code In addition to having one or more components, your application can also include application code. In application code, you declare and initialize application variables and perform tasks that affect the entire application. The application code ﬁle is named Application and its extension is based on the programming language you use to create it (Application.wos, Application.java, or Application.m).
PAGE 24

Chapter 1 What Is a WebObjects Application? where they are used by reading the chapter “WebObjects Viewed Through Its Classes” (page 63). Components are subclasses of a class named WOComponent. For example, in Figure 1 the component directory creates a WOComponent subclass named Main. Application ﬁles create subclasses of a class named WOApplication, and session ﬁles create subclasses of a class named WOSession.
PAGE 25

Running a WebObjects Application Now you’ve learned what a WebObjects application looks like and seen the pieces that you’ll have to write. The next section tells you how to run a WebObjects application. Running a WebObjects Application WebObjects applications run on a web server. Your users connect to a WebObjects application using web browsers that they run on their own (client) machines.
PAGE 26

Chapter 1 What Is a WebObjects Application? Web Browser Figure 5. HTTP Server WebObjects Adaptor WebObjects Application Chain of Communication Between the Browser and Your WebObjects Application Here is a brief description of these processes: • An HTTP server. Any HTTP server that uses the Common Gateway Interface (CGI), the Netscape Server API (NSAPI), or the Internet Server API (ISAPI). • A WebObjects adaptor.
PAGE 27

Running a WebObjects Application Internet Server API (ISAPI). Thus, WebObjects adaptors can take advantage of server-speciﬁc interfaces but still provide server independence. By default, WebObjects uses the WebObjects CGI adaptor. The Common Gateway Interface is supported by all HTTP servers, so you can use the CGI adaptor with any server—including those that are publicly available.
PAGE 28

Chapter 1 What Is a WebObjects Application? associated with the user’s action, and generates a response—usually an HTML page (see Figure 8). Web Browser Request Page HTTP Server Request WebObjects Adaptor Request User performs an action Response Page 28 1. Take Values From Request 2. Invoke Action Response User sees the next page Figure 8. WebObjects Applications The Request-Response Loop Response 3.
PAGE 29

Chapter 2 Dynamic Elements
PAGE 30
PAGE 31

In the previous chapter, you learned that a WebObjects application is made up of components, which in turn are made up of dynamic elements. Dynamic elements are the basic building blocks of a WebObjects application. They link an application’s behavior with the HTML page shown in the web browser, and their contents are deﬁned at runtime.
PAGE 32

Chapter 2 Dynamic Elements This list is not hard-coded into the page. Instead, it is produced by several dynamic elements. Figure 10 shows how this same part of the page looks in WebObjects Builder. Figure 10. CyberWind Main Page in WebObjects Builder The elements shown in Figure 10 are a WORepetition, a WOHyperlink, and a WOString. The WORepetition element corresponds to a for loop in C code. That is, it iterates through a list of items and, for each item in that list, prints its contents.
PAGE 33

Server-Side Dynamic Elements Web Browser Response Page Dynamic Element <...> Dynamic Element <...> Dynamic Element Client <...> Server Figure 11. Server-Side Dynamic Elements How Server-Side Dynamic Elements Work To learn how server-side dynamic elements work, look once more at the Main page of the CyberWind example in WebObjects Builder.
PAGE 34

Chapter 2 Dynamic Elements In the .wod ﬁle, each element is identiﬁed by name and then its type is speciﬁed. The outermost dynamic element in the HTML ﬁle (OPTION_REPETITION) deﬁnes a WORepetition, the next element is a WOHyperlink, and the innermost element is a WOString. Each type speciﬁcation is followed by a list of attributes. Dynamic elements deﬁne several attributes that you bind to different values to conﬁgure the element for your application.
PAGE 35

Server-Side Dynamic Elements Finally, the WOString element deﬁnes a value attribute, which speciﬁes the string you want displayed. This value attribute is bound to the currentOption variable, which is also bound to the item attribute of the WORepetition. As you’ll recall, currentOption is updated with each iteration that the WORepetition makes.
PAGE 36

Chapter 2 Dynamic Elements • It resolves the value for the upSince key by looking for a method named upSince in the application object. If the method is not found, it looks for an upSince instance variable. In this case, the upSince instance variable is deﬁned in the application’s code ﬁle. • It resolves the value for the description key by looking for a method named description in the upSince object.
PAGE 37

Client-Side Java Components elementName : elementType { attribute = value; attribute = value }; Notice that the last attribute/value pair before a closing brace (}) does not end with a semicolon (;). As described in the previous section, value can be a constant, variable, or method. It can also be a string of messages joined by a dot, similar to the Java syntax for sending messages but without the parentheses. For example: application.upSince.
PAGE 38

Chapter 2 Dynamic Elements When client-side components are used, an HTTP request can result in either the resynchronization of state or the return of a new page. Thus, state can be synchronized without the page having to be redrawn (see Figure 13). Client-Side Component Web Browser HTML WOApplet Dynamic Element Association attributes Client Server Figure 13. Client-Side Java Components • Client-side components are more ﬂexible than server-side dynamic elements.
PAGE 39

Client-Side Java Components When you look at client-side component’s bindings in the .wod ﬁle, it looks like this example: INPUTFIELD : WOApplet { code = "next.wo.client.controls.TextFieldApplet.class"; codebase = "/WebObjects/Java"; archive = "woextensions.jar"; width = "200"; height = "20"; associationClass = "next.wo.client.
PAGE 40
PAGE 41

Chapter 3 Common Methods
PAGE 42
PAGE 43

The methods that you write for your WebObjects application provide the behavior that makes your application unique. Because you are writing subclasses of WOApplication, WOSession, and WOComponent (in Java, WebApplication, WebSession, and Component), you inherit the methods provided by those classes. These inherited methods take care of the details of receiving HTTP requests and generating responses.
PAGE 44

Chapter 3 Common Methods name and click the button. This initiates the application’s request-response loop, and sayHello is invoked. Action methods take no arguments and return a page (component) that will be packaged with an HTTP response. For example, the sayHello method creates a new page named Hello and sends that page the name the user has typed into the text ﬁeld. //WebScript HelloWorld Main.
PAGE 45

Action Methods // Java example public Component showPart() { Error errorPage; Inventory inventoryPage; if (isValidPartNumber(partNumber)) { errorPage = (Error)application().pageWithName("Error"); errorPage.setErrorMessage("Invalid part number " + partnumber); return errorPage; } inventoryPage = (Inventory) application().pageWithName("Inventory"); inventoryPage.setPartNumber(partnumber); return inventoryPage; } Action methods don’t have to return a new page.
PAGE 46

Chapter 3 Common Methods Initialization and Deallocation Methods Like all objects, WOApplication, WOSession, and WOComponent implement initialization methods (or constructors in Java). Because most subclasses require some unique initialization code, these are the methods that you override most frequently. In WebScript, the initialization methods are init and awake. In Java, the initialization methods are the constructor for the class and awake.
PAGE 47

Initialization and Deallocation Methods - awake { /* initializations go here */ } public void awake () { /* initializations go here. */ } Application Initialization The application init method is invoked only once, when the application is launched. You perform two main tasks in the application’s init method: • • Initialize application variables Conﬁgure applicationwide settings For example, the Visitors application has this init method in Application.wos: // WebScript Visitors Application.
PAGE 48

Chapter 3 Common Methods // WebScript DodgeDemo Application.wos - awake { ++requestCount; [self logWithFormat:@"Now serving request %@", requestCount]; } // Java DodgeDemo Application.java public void awake() { ++requestCount; this.logString("Now serving request " + requestCount); } Session Initialization A session object is created each time the application receives a request from a new user. An application may have multiple sessions running concurrently.
PAGE 49

Initialization and Deallocation Methods Component Initialization A component object’s init method is invoked when the component object is created. Just how often a particular component object is created depends on whether the application object is caching pages. For more information, see “WebObjects Viewed Through Its Classes” (page 63).
PAGE 50

Chapter 3 Common Methods or null in Java). For more information, see the chapter “Managing State” (page 109).
PAGE 51

Request-Handling Methods As you implement request-handling methods, you must invoke the superclass’s implementation of the same methods. But consider where you invoke it because it can affect the request, response, and context information available at any given point. In short, you want to perform certain tasks before super is invoked and other tasks after super is invoked.
PAGE 52

Chapter 3 Common Methods Invoking an Action The second phase of the request-response loop involves invokeActionForRequest:inContext:. WebObjects forwards this method from object to object until it is handled by the dynamic element associated with the user action (typically, a submit button, a hyperlink, and active image, or a form). Use invokeActionForRequest:inContext: if you want to return a page other than the one requested.
PAGE 53

Request-Handling Methods following action method, the “CreditCard” component sets the veriﬁed session variable to YES when the user has supplied valid credit information and returns the user to the original request page to try again. - verifyUser { if ([self isValidCredit]) { [[self session] setVerified:YES]; return [[self application] pageWithName:nameOfNextPage]; } return nil; } Limitations on Direct Requests Users can access any page in an application without invoking an action.
PAGE 54

Chapter 3 Common Methods appendToResponse:inContext: method adds bold and italic markup elements around a string’s value as follows: id id id id value; escapeHTML; isBold; isItalic; - appendToResponse:aResponse inContext:aContext { id aString = [value description]; [super appendToResponse:aResponse inContext:aContext]; [aResponse appendContentHTMLAttributeValue:@"
"]; if (isBold) { [aResponse appendContentHTMLAttributeValue:@""]; } if (isItalic) { [aResponse appendContentHTMLAttributeValue:@""];

PAGE 55

Chapter 4 Debugging a WebObjects Application

PAGE 56

PAGE 57

In the previous chapters, you learned the pieces of a WebObjects application and the kinds of methods you need to write. Once you’ve put together an application, you should debug it to make sure it runs properly. The techniques you use to debug vary according to the languages you’ve used to write the application. This chapter describes how to debug WebScript code, Java code, and Objective-C code in a WebObjects application. When you debug, you’ll be using the Project Builder application.

PAGE 58

Chapter 4 Debugging a WebObjects Application executable in the launch panel. Output from the debugging methods appears in the launch panel. Debugging Objective-C If all or part of your application is written in Objective-C, you can use the gdb debugger in Project Builder. For more information on debugging an ObjectiveC application with Project Builder, see Project Builder’s online help.

PAGE 59

Debugging Techniques In WebScript and Objective-C, logWithFormat: works like the printf() function in C. This method takes a format string and a variable number of additional arguments. For example, the following code excerpt prints the string “The value of myString is Elvis”: myString = @"Elvis"; [self logWithFormat:@"The value of myString is %@", myString]; When this code is parsed, the value of myString is substituted for the conversion speciﬁcation %@.

PAGE 60

Chapter 4 Debugging a WebObjects Application methods are useful if you want to see all or part of the call stack. The following table describes the trace methods: Method Description – trace: Enables all tracing. – traceAssignments: Logs information about all assignment statements. – traceStatements: Logs information about all statements. – traceScriptedMessages: Logs information when an application enters and exits a scripted method.

PAGE 61

Programming Pitfalls to Avoid • WebScript supports only objects that inherit from NSObject. As most objects inherit from NSObject, this limitation is easy to overlook. Notably, EOFault does not inherit from NSObject, so you cannot use it in WebScript code. • The == operator is supported only for NSNumber objects. If you use == to compare two objects of any other class, the operator compares the addresses of the two objects, not the values of the two objects.

PAGE 62

Chapter 4 Debugging a WebObjects Application • The pageWithName method creates the page by looking up and instantiating the component class that has the same name as the argument you provide to pageWithName. For this reason, your subclass of Component shouldn’t be given a package name. For example, if you create a component named MyPage.wo and place its Java ﬁle in the package myClasses.web, pageWithName won’t ﬁnd the MyPage.class ﬁle.

PAGE 63

Chapter 5 WebObjects Viewed Through Its Classes

PAGE 64

PAGE 65

The Classes in the Request-Response Loop As you learned at the end of the ﬁrst chapter, WebObjects applications respond to HTTP requests from the server and return responses in the form of dynamically generated HTML pages. The main loop of a WebObjects application, in which the application performs this work, is called the request-response loop.

PAGE 66

Chapter 5 WebObjects Viewed Through Its Classes Request HTTP server application adaptor Response Figure 14. Request-Response Loop: Application and Server Level The HTTP server sends a request to the application’s adaptor. The adaptor packages the incoming HTTP request in a form the WebObjects application can understand and forwards it to the application.

PAGE 67

The Classes in the Request-Response Loop Request HTTP server adaptor application session store session 1 Response session 2 Figure 15. Request-Response Loop: Session Level The objects dedicated to session management ensure that state with sessionwide scope persists between cycles of the request-response loop. Two classes are involved at this level: • WOSession (in Java, WebSession) Encapsulates the state of a session. WOSession objects persist between the cycles of the request-response loop.

PAGE 68

Chapter 5 WebObjects Viewed Through Its Classes When a user makes an initial request to a WebObjects application, the application creates a session object (WOSession). At the end of the requestresponse cycle, the application stores the state-bearing session object using the facilities of WOSessionStore. With each subsequent cycle of the requestresponse loop for that user, the application restores the state of the session at the beginning of the cycle and stores it again at the end of the cycle.

PAGE 69

The Classes in the Request-Response Loop • WOResponse (in Java, Response) Stores and allows the modiﬁcation of HTTP response data, such as header information, status, and HTTP version. It also provides convenience methods for appending HTML and simple textual data to the content of the response (that is, the response page). • WOContext (in Java, Context) Provides access to the objects involved in the current cycle, such as the current request, response, session, and application objects.

PAGE 70

Chapter 5 WebObjects Viewed Through Its Classes Request session store session 1 HTTP server adaptor application transaction 1 request page response page transaction 2 Response request page response page session 2 Figure 17. Request-Response Loop: Page Level Two major branches of these objects descend from WOElement: WOComponent objects, which represent components, and WODynamicElement objects, which represent dynamic HTML elements on the page.

PAGE 71

The Classes in the Request-Response Loop • WOAssociation (in Java, Association) Knows how to ﬁnd and set a value by reference to a key. Instance variables and action methods of dynamic elements are instances of this class. Database Integration Level Database integration is handled mainly by classes in the Enterprise Objects Framework (see Figure 18).

PAGE 72

Chapter 5 WebObjects Viewed Through Its Classes dynamic elements on your page and the objects in the Enterprise Objects Framework. • EOEditingContext (in Java, next.eo.EditingContext) Manages a graph of objects fetched from a database. The objects represent tables, rows, and columns in the database. When a WebObjects application accesses a database, one or more of the components in the application contain one or more WODisplayGroup objects.

PAGE 73

How WebObjects Works—A Class Perspective HTTP server and the WOApplication object. The application ﬁrst parses the command line for the speciﬁed adaptors (with necessary arguments); if none are speciﬁed, as happens when the application is autostarted, it creates a suitable default adaptor. The run method initiates the request-response loop. When run is invoked, the application sends registerForEvents to each of its adaptors to tell them to begin receiving events.

PAGE 74

Chapter 5 WebObjects Viewed Through Its Classes Application init awake Create WOSession or Restore WOSession Create page or Restore page takeValuesFrom Request:inContext: Session Request Page Page Template init awake init awake takeValuesFrom Request:inContext: Gets request page and stores reference to it. takeValuesFrom Request:inContext: Gets template for page.

PAGE 75

How WebObjects Works—A Class Perspective HTTP server name adaptor name http://ursa/cgi-bin/WebObjects/SomeWebApp name of the Web server's cgi-bin directory application path relative to / WebObjects Figure 20. URL to Start a WebObjects Application This URL does not contain a session ID, so the application object creates a new session by performing the following steps: 1. It sends itself a createSession message. 2.

PAGE 76

Chapter 5 WebObjects Viewed Through Its Classes transactions from that of another, session IDs must not be easily predicted or faked. To this end, WebObjects uses randomly generated 32-digit integers as session IDs. (You can also override WOSession’s sessionID method and implement another security scheme if you’d like.) The application keeps existing, active sessions in the WOSessionStore object.

PAGE 77

How WebObjects Works—A Class Perspective class for the page named “Main.” The application object performs the following steps to create a component: 1. It looks in the runtime system for a WOComponent subclass that has the same name as the request page (in this case, “Main”). If it ﬁnds such a class with the same name, it creates an instance of that class. 2. If the application object fails to ﬁnd a class in the runtime system, it looks for a scripted component with the name of the request page.

PAGE 78

Chapter 5 WebObjects Viewed Through Its Classes subscription for a friend. You follow the process a second time, selecting a different publication and entering your friend’s address. At this point, within a single session with the subscriptions application, you’ve accessed the same pages twice, entering different information each time. Let’s say that you now realize that you made a mistake in your own address, so you backtrack to that page, change the address, and resubmit the information.

PAGE 79

How WebObjects Works—A Class Perspective For more on how components are associated with templates, and on how HTML elements participate in request-handling, see “How HTML Pages Are Generated” (page 82). Invoking an Action In the second phase of the request-response loop (see Figure 23), the application ﬁrst determines which dynamic element the user has clicked (or otherwise activated) and then has that element trigger the appropriate action method in the request component.

PAGE 80

Chapter 5 WebObjects Viewed Through Its Classes message and invoke the appropriate action method in the request component. This action method returns the response page. To be suitable, an element must be able to respond to user actions (a WOSubmitButton or a WOActiveImage, for example). Each of these elements evaluates the invoked action to determine if it “owns” it.

PAGE 81

How WebObjects Works—A Class Perspective 1. The application object stores the response component indicated by the action method’s return value. (This action method was invoked during the second phase of the request-response loop.) 2. If the response component is different from the request component, application sends the awake message to the response component. 3.

PAGE 82

Chapter 5 WebObjects Viewed Through Its Classes 4. It saves the session object in the session store. 5. It invokes its own sleep method. When an Objective-C object is about to be destroyed, its dealloc method is invoked at an undeﬁned point in time after a cycle (indicated by the vertical ellipses in Figure 24). In the dealloc method, the object releases any retained instance variables.

PAGE 83

How HTML Pages Are Generated page (component) page template Figure 25. An Object Graph for a Page’s Template The template is created at runtime when the component is ﬁrst requested. The template is part of a larger component deﬁnition, which also includes information that allows instances of this component to share resources. Instances carry only the instance-variable values that are distinctive to them; the rest is stored in the component deﬁnition.

PAGE 84

Chapter 5 WebObjects Viewed Through Its Classes Associations and the Current Component A dynamic HTML element, such as a text ﬁeld or a pop-up button, differs from a static HTML element, such as a heading, in that its attributes can change over a cycle of the request-response loop.

PAGE 85

How HTML Pages Are Generated START:Calendar { selectedDate = startDate; callBack = "mainPage"; }; In this example, Main is the parent component and Calendar is the child component. The startDate variable belongs to the parent component while selectedDate is a variable of the child component. A change in the parent component instance variable is automatically communicated through the association to the child variable.

PAGE 86

Chapter 5 WebObjects Viewed Through Its Classes associate particular events in the client applet (such as clicking a button) with the invocation of methods in the server. State is synchronized between the client and the server in three phases: 1. When a page is ﬁrst generated, the server sends the client all state for which there are bindings. 2. Before an action is invoked in the server, the client sends the server any of its state that has changed. 3.

PAGE 87

How HTML Pages Are Generated page template page component calendar component reference calendar instance = page component calendar instance calendar template = subcomponent = static element = dynamic element Figure 26.

PAGE 88

PAGE 89

SPECIAL TASKS

PAGE 90

PAGE 91

Chapter 6 Creating Reusable Components

PAGE 92

PAGE 93

In the simplest applications, each component corresponds to an HTML page, and no two applications share components. However, one of the strengths of the WebObjects architecture is its support of reusable components: components that, once deﬁned, can be used within multiple applications, multiple pages of the same application, or even multiple sections of the same page. This chapter describes reusable components and shows you how to take advantage of them in your applications.

PAGE 94

Chapter 6 Creating Reusable Components Figure 27. A Navigational Control The HTML code for one page might look like this: World Wide Web Wisdom, Inc. Please come visit us again!

World Wide Web Wisdom, Inc.

Home PAGE 95
Beneﬁts of Reusable Components World Wide Web Wisdom, Inc. Please come visit us again! The thirteen lines are reduced to one, which positions the WebObject named NAVCONTROL.

PAGE 96

Chapter 6 Creating Reusable Components the World Wide Web Wisdom company could change the look of the navigational controls in all of its applications by changing this one component. If your application’s pages are highly structured, reusable components could be the prevailing feature of each page: World Wide Web Wisdom, Inc.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-97.html">PAGE 97</a></h6> <p>Beneﬁts of Reusable Components Figure 28. An Alert Panel This panel is similar to the navigation table shown in Figure 27, but as you’ll see, most of the component’s attributes are customizable.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-98.html">PAGE 98</a></h6> <p>Chapter 6 Creating Reusable Components the alertTitle and infoString attributes (leaving the other attributes private) using this AlertPanel.api ﬁle: Required = (alertTitle, infoString); Optional = (); See the WebObjects Tools and Techniques online book for more information. AlertPanel is one of several components included in a sample application called ReusableComponents. This application demonstrates and documents how to create and use reusable components.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-99.html">PAGE 99</a></h6> <p>Intercomponent Communication For reusable components to be truly versatile, there must also be a mechanism for the child component to interact with the parent, either by setting the parent’s variables or invoking its methods, or both. This mechanism must be ﬂexible enough that a given child component can be reused by various parent components without having to be modiﬁed in any way. WebObjects provides just such a mechanism, as illustrated by the following example.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-100.html">PAGE 100</a></h6> <p>Chapter 6 Creating Reusable Components The parentAction attribute identiﬁes a callback method, one that the child component invokes in the parent when the user clicks the Yes or No link. The exitStatus attribute identiﬁes a variable that the parent can check to discover which of the two links was clicked. This attribute passes state information from the child to the parent. A reusable component can have any number of callback and state attributes, and they can have any name you choose.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-101.html">PAGE 101</a></h6> <p>Intercomponent Communication invoked by the child. In this example parentAction identiﬁes the parent method named "respondToAlert", as speciﬁed in the parent’s declarations ﬁle. Note: You must enclose the name of the parent’s action method in quotes. Now, looking at the rejectChoice and acceptChoice method implementations, you can see that they are identical except for the assignment to exitStatus.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-102.html">PAGE 102</a></h6> <p>Chapter 6 Creating Reusable Components Parent1’s Declarations File (excerpt) ALERT: AlertPanel { ... parentAction = "respondToAlert"; exitStatus = usersChoice; }; Parent2’s Declarations File (excerpt) ALERT: AlertPanel { ... parentAction = "okCancel"; exitStatus = result; }; Parent3’s Declarations File (excerpt) ALERT: AlertPanel { ...</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-103.html">PAGE 103</a></h6> <p>Intercomponent Communication For the sake of illustration, consider a page that displays a value in two different text ﬁelds—one provided by the parent component and one by the child (see Figure 31). Figure 31. Synchronized Components Setting the value of either text ﬁeld and submitting the change causes the new value to appear in both text ﬁelds.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-104.html">PAGE 104</a></h6> <p>Chapter 6 Creating Reusable Components For instance, it’s sufﬁcient in the example shown in Figure 31 to simply declare a childValue instance variable in the child component and a parentValue instance variable in the parent. You need to implement accessor methods (such as setChildValue: and childValue) only if the component must do some calculation (say, determine how long the application has been running) before returning the value.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-105.html">PAGE 105</a></h6> <p>Search Path for Reusable Components 4. Build the framework. If you perform a make install, it installs the framework in NeXT_ROOT/NextLibrary/Frameworks and the WebServer resources in <DocRoot>/WebObjects/Frameworks. You must build the framework even if it contains only scripted components. After the framework is installed, you need to set up the applications so that they can use components in that framework. Do the following: 5.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-106.html">PAGE 106</a></h6> <p>Chapter 6 Creating Reusable Components that were linked in to the application executable for a component with that name. For example, applications written entirely in WebScript use the default application executable, WODefaultApp. This executable is linked to the frameworks WebObjects.framework and WOExtensions.framework, so any components deﬁned in either of these two frameworks can be used in a scripted application.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-107.html">PAGE 107</a></h6> <p>Designing for Reusability • Provide attributes for all signiﬁcant features. The more customizable a component is, the more likely it is that people will be able to reuse it. For example, if the AlertPanel component discussed in “Intercomponent Communication” (page 98) let you set the titles of the hyperlinks (say, to OK and Cancel, or Send Now and Send Later), the panel could be adapted for use in many more applications. • Provide default values for attributes wherever possible.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-108.html">PAGE 108</a></h6> <p>Chapter 6 Creating Reusable Components This declaration speciﬁes a value for just one attribute; all others will use the default values provided by the component’s init method: Partial Declaration ALERT: AlertPanel { alertString = "Choice not available."; }; • Consider building reusable components from reusable components. Rather than building a monolithic component, consider how the ﬁnished component can be built from several, smaller components.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-109.html">PAGE 109</a></h6> <p>Chapter 7 Managing State</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-110.html">PAGE 110</a></h6> <p></p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-111.html">PAGE 111</a></h6> <p>Most applications must be able to preserve some application state between a user’s requests. For example, if you’re writing a catalog application, you must keep track of the items that the user has selected before the user actually ﬁlls out the purchasing information. By default, WebObjects stores application state on the server. If this doesn’t meet your needs, WebObjects provides several alternatives strategies for storing state.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-112.html">PAGE 112</a></h6> <p>Chapter 7 Managing State • Storing state information on the server. With each transaction, the web application locates the state information associated with a request from a particular client. The state information might be stored in memory, in a ﬁle on disk, or in a standard database, depending on the application. Passing state back to the client with every transaction simpliﬁes the accounting associated with state management but is inefﬁcient and can constrain the design of your site.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-113.html">PAGE 113</a></h6> <p>Objects and State Characteristically, WebObjects takes an object-oriented approach to fulﬁlling any of these state-storage requirements. Objects and State Three classes manage state in an application—WOApplication, WOSession, and WOComponent. (In Java, these classes are called WebApplication, WebSession, and Component.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-114.html">PAGE 114</a></h6> <p>Chapter 7 Managing State // Java DodgeLite Application.java public class Application extends WebApplication { public ImmutableHashtable dodgeData; public ImmutableVector prices; public ImmutableVector sortBys; public Application() { super(); String filePath = resourceManager() .pathForResourceNamedInFramework("DodgeData.dict", null); if (null != filePath) { try { dodgeData = new ImmutableHashtable(new java.io.FilePath(filePath)); } catch (Exception e) { //... } } else { // ...</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-115.html">PAGE 115</a></h6> <p>Objects and State The WOComponent class deﬁnes a method application, which provides access to the component’s application object. So any component can access application state this way: //Java public boolean isLuckyWinner() { Number sessionCount = application().statisticsStore().</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-116.html">PAGE 116</a></h6> <p>Chapter 7 Managing State // WebScript elapsedTime = [[self session] timeSinceSessionBegan]; //Java elapsedTime = this.session().timeSinceSessionBegan(); The application object can also access session state using the same method deﬁned in WOApplication. The WOSession class provides a dictionary where state can be stored by associating it with a key. WOSession’s setObject:forKey: and objectForKey methods (in Java, setObject and objectForKey) give access to this dictionary.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-117.html">PAGE 117</a></h6> <p>Objects and State //Java example String componentName; Context context; String contextID; String elementID; String uniqueKey; context = this.context(); componentName = context.component().name(); contextID = context.contextID(); elementID = context.elementID(); uniqueKey = componentName + "-" + contextID + "-" + elementID; this.session().</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-118.html">PAGE 118</a></h6> <p>Chapter 7 Managing State Component Objects and Component State In WebObjects, state can also be scoped to a component, such as a dynamically generated page or a reusable component within a page.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-119.html">PAGE 119</a></h6> <p>Objects and State // Java DodgeLite Main.java ImmutableVector models, prices, types; MutableVector selectedModels, selectedPrices, selectedTypes; String model, price, type; public Main() { super(); java.util.Enumeration en; Application woApp = (Application)application(); en = woApp.modelsDict().elements(); models = new MutableVector(); while (en.hasMoreElements()) ((MutableVector)models).addElement(en.nextElement()); en = woApp.typesDict().elements(); while (en.hasMoreElements()) ((MutableVector)types.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-120.html">PAGE 120</a></h6> <p>Chapter 7 Managing State // Java DodgeLite Main.java public Component displayCars() { SelectedCars selectedCarsPage = (SelectedCars)application().pageWithName("SelectedCars"); ... selectedCarsPage.setModels(selectedModels); selectedCarsPage.setTypes(selectedTypes); selectedCarsPage.setPrices(selectedPrices); ... selectedCarsPage.fetchSelectedCars(); return (Component)selectedCarsPage; } // WebScript DodgeLite Main.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-121.html">PAGE 121</a></h6> <p>State Storage Strategies • In cookies. State is embedded in name-value pairs (“cookies”) in the HTTP header and passed between the client and server. Like “statein-the-page,” cookies store state on the client. • In custom stores. State is stored using a mechanism of your own design. By default, WebObjects uses the ﬁrst approach, storing state on the server.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-122.html">PAGE 122</a></h6> <p>Chapter 7 Managing State State in Server Other State in Page State in Cookies Performance can suffer if lots of data is passed back and forth between client and server. State can become out of sync, especially when using frames. Client can refuse to accept cookies. Custom Storage A Closer Look at Storage Strategies To compare and further understand state-storage options, look at the SessionStores sample application. This application presents the user with a choice of storage strategies: Figure 33.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-123.html">PAGE 123</a></h6> <p>State Storage Strategies applications—changing storage strategies midsession can cause errors. For example, imagine an application that stores state in the page during the ﬁrst half of a session and stores state in cookies for the second. Now, suppose that the user backtracks from a page in the second half to one in the ﬁrst and resubmits the page. The application’s strategy and the actual storage mechanism won’t match, and state will be lost.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-124.html">PAGE 124</a></h6> <p>Chapter 7 Managing State • Page uniquing by implementing pageWithName: in the session object (see “pageWithName: and Page Caching” (page 138)) A signiﬁcant consequence of storing state in memory is the effect on loadbalanced applications. When an application is load balanced, there are several instances of that application running on different physical machines to reduce the load on a particular server. (The online book Serving WebObjects describes how to set this up.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-125.html">PAGE 125</a></h6> <p>State Storage Strategies <FORM METHOD=Post ACTION=someAction> Can you guess my favorite digit?<BR> <SELECT NAME="guesses"> <OPTION>1 <OPTION>2 ...</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-126.html">PAGE 126</a></h6> <p>Chapter 7 Managing State • Backtracking. Because each page carries a record of the state existing at the time of its creation, backtracking can make the page state and the actual state disagree. If, for example, the user make ﬁve guesses in the SessionStores example, backtracks two pages, and submits another guess, the application will claim that four guesses were made, when the actual number is six. • Frames. Storing state in the page is a problem if the “pages” in question are frames.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-127.html">PAGE 127</a></h6> <p>State Storage Strategies Field Description domain The Internet domain name for which the cookie is valid. If, for example, the speciﬁed domain is apple.com for a given cookie, that cookie is returned along with a request to any host whose domain ends in apple.com (for example, www.apple.com)—assuming the URL is within the directories speciﬁed by path. path The directories within a given domain for which this cookie is valid. If, for example, a cookie has a domain of www.apple.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-128.html">PAGE 128</a></h6> <p>Chapter 7 Managing State NSData object is then asked for its ASCII representation. WebObjects pairs this data with names it generates and creates the Set-Cookie headers of the response page. The process is reversed when a user submits a request containing cookies. The ASCII archive from the Set-Cookie headers is converted to its binary, NSData, representation. The session object and the components it contains are then unarchived from the NSData object, thus restoring the session state.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-129.html">PAGE 129</a></h6> <p>State Storage Strategies // WebScript StateStorage FileSessionStore.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-130.html">PAGE 130</a></h6> <p>Chapter 7 Managing State // Unarchive session restoredSession = [NSUnarchiver unarchiveObjectWithData:archivedSession]; return restoredSession; } - saveSession:aSession { id request = [[WOApp context] request]; // Store data corresponding to session only if necessary.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-131.html">PAGE 131</a></h6> <p>Storing State for Custom Objects Storing State for Custom Objects When state is stored in the server, the objects that hold state are kept intact in memory between cycles of the request-response loop. In contrast, when state is stored in the page, in cookies, or in the ﬁle system, objects are asked to archive themselves (using classes and methods deﬁned in the Foundation framework) before being put into storage.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-132.html">PAGE 132</a></h6> <p>Chapter 7 Managing State • During unarchiving, an EOEditingContext can recreate individual objects in the graph only as they are needed by the application. This approach can signiﬁcantly improve an application’s perceived performance. An enterprise object (like any other object that uses the OpenStep archiving scheme) makes itself available for archiving by declaring that it conforms to the NSCoding protocol and by implementing the protocol’s two methods, encodeWithCoder: and initWithCoder:.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-133.html">PAGE 133</a></h6> <p>Controlling Session State You can see implementations of encodeWithCoder: and initWithCoder: in the DodgeDemo application, in the class ShoppingCart.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-134.html">PAGE 134</a></h6> <p>Chapter 7 Managing State much state is stored. This section takes a closer look at how you manage sessionwide state. Take care that your application only stores state for active sessions and stores the smallest amount of state possible. WOSession lets you control these factors by providing a time-out mechanism for inactive sessions and by providing a way to specify exactly what state to store between request-response loop cycles.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-135.html">PAGE 135</a></h6> <p>Controlling Component State At times, a user’s choice signals the end of a session (such as when the Yes button is clicked in response to the query, “Do you really want to leave the Intergalactic Web Mall?”). If you are sure a session has ended, you can send a terminate message to the session object, marking it (and the resources it holds) for release. A session marked for release won’t actually be released until the end of the current request-response loop.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-136.html">PAGE 136</a></h6> <p>Chapter 7 Managing State Adjusting the Page Cache Size As noted in “WebObjects Viewed Through Its Classes” (page 63), except for the ﬁrst request, a request to a WebObjects application contains a session ID, page name, and context ID. The application uses this information to ask the appropriate session object for the page identiﬁed by the name and context ID. As long as the page is still in the cache, it can be retrieved and enlisted in handling the request.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-137.html">PAGE 137</a></h6> <p>Controlling Component State responsibility for maintaining any needed component state. For this reason, it’s rarely advisable to turn off page caching. Using awake and sleep Another way to control the amount of component state that’s maintained between cycles is to make use of WOComponent’s awake and sleep methods.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-138.html">PAGE 138</a></h6> <p>Chapter 7 Managing State pageWithName: and Page Caching When the application object receives a pageWithName: message, it creates a new component. For example, in the HelloWorld example a user enters a name in the ﬁrst page (the Main component), clicks Submit, and is presented with a personal greeting on the second page (the Hello component). Clicking the Submit button in the ﬁrst page invokes the sayHello method in the Main component.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-139.html">PAGE 139</a></h6> <p>Controlling Component State // example Application.java public Component pageWithName(String aName) { Component aPage; if (aName == null) aName = "Main"; aPage = ((Session)session()).pageWithName(aName); if (aPage == null) { aPage = super.pageWithName(aName); ((Session)session().storePage(aName, aPage); } return aPage; } Note that we store pages in the session object because we want to cache these pages on a per-session basis.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-140.html">PAGE 140</a></h6> <p>Chapter 7 Managing State A WebObjects application handles a page-refresh request differently than it would a standard request. When the application determines that the request URL is identical to one it has previously received (that is, the session and context IDs in the request URL are identical to those in a request it has previously received), it simply returns the response page that was associated with this earlier request.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-141.html">PAGE 141</a></h6> <p>Chapter 8 Creating Client-Side Components</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-142.html">PAGE 142</a></h6> <p></p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-143.html">PAGE 143</a></h6> <p>In earlier chapters, you learned about client-side Java components. Clientside components are Java applets that your application can use instead of server-side dynamic elements to interact with users. WebObjects comes with several premade client-side components. To use them you simply add them to your application in much the same way that you add a server-side dynamic element.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-144.html">PAGE 144</a></h6> <p>Chapter 8 Creating Client-Side Components destination applets are. To determine these, it inspects the visible applets on the page and looks for some special parameters. client (browser) server page Java Applet AppletGroup Controller Association Figure 37. The Principal Objects Involved in Client-Side Components SimpleAssociation objects don’t get or set values themselves; instead, they rely on the actual client-side components to do so.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-145.html">PAGE 145</a></h6> <p>When You Have an Applet’s Source Code 1. In Project Builder, add the ClientSideJava subproject to your project. To do so, double-click the word “Subprojects” in the browser and then choose ClientSideJava.subproj in the Open panel. When you build your project, Project Builder builds both the individual Java .class ﬁles and a .jar ﬁle containing the entire ClientSideJava subproject. This way, you have the option of using WOApplet’s archive binding for browsers that support .jar ﬁles. 2.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-146.html">PAGE 146</a></h6> <p>Chapter 8 Creating Client-Side Components The value for a key must be a property-list type of object (either singly or in combination, such as an array of string objects). The corresponding property-list type of objects for Objective-C and Java are: Objective-C Java NSString String NSArray Vector NSDictionary Hashtable NSData byte[] The remaining steps apply only if the applet has an action. 6.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-147.html">PAGE 147</a></h6> <p>When You Don’t Have an Applet’s Source Code 1. Declare a subclass of the Association class. class MyAssociation extends Association { ... } 2. Implement the keys method to return a list (Vector) of keys managed by the applet. See “When You Have an Applet’s Source Code” (page 144) for an example. 3. Implement the takeValueForKey and valueForKey methods to set and get the values of keys. Use Association’s destination method to obtain the destination object (that is, the applet).</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-148.html">PAGE 148</a></h6> <p></p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-149.html">PAGE 149</a></h6> <p>Chapter 9 Deployment and Performance Issues</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-150.html">PAGE 150</a></h6> <p></p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-151.html">PAGE 151</a></h6> <p>After you’ve written your application, tested it, and veriﬁed that it works properly, it’s ready to be deployed for use by your customers. Before you deploy, you’ll want to perform some ﬁnishing touches. For example, if you included any logWithFormat: (or logString) statements in your code for debugging purposes, you’ll probably want to remove them before you deploy. This chapter describes ﬁnishing touches that you might want to add after you’re through debugging the bulk of your application’s code.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-152.html">PAGE 152</a></h6> <p>Chapter 9 Deployment and Performance Issues Accessing Statistics If your application has a WOStats page, you can look at the statistics that WOStatisticsStore gathers. WOStats is a reusable component stored in the WOExtensions framework (which WebObjects applications link to by default). While your application is running, you can access the WOStats page with a URL like the following: http://localhost/cgi-bin/WebObjects/MyWebApp.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-153.html">PAGE 153</a></h6> <p>Recording Application Statistics // WebScript NSDictionary *myDict = [[[self application] statisticsStore] statistics]; // Java ImmutableHashTable myDict = this.application().statisticsStore().statistics; For a list of keys to this dictionary, see the WOStatisticsStore class speciﬁcation in the WebObjects Class Reference. Recording Extra Information There may be occasions when you want to have the WOStatisticsStore object record more information than it usually does.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-154.html">PAGE 154</a></h6> <p>Chapter 9 Deployment and Performance Issues Error Handling When an error occurs, WebObjects by default returns a page containing debugging information and displays that page in the web browser. This information is useful when you’re in the debugging phase, but when you’re ready to deploy, you probably want to make sure that your users don’t see such information. The WOApplication class (WebApplication in Java) provides the following methods that you can override to show your own error page.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-155.html">PAGE 155</a></h6> <p>Automatically Terminating an Application Automatically Terminating an Application Unless an application is very carefully constructed, the longer it runs, the more memory it consumes. As more memory is consumed, the server machine’s performance begins to degrade. For this reason, you may ﬁnd that performance is greatly improved if you occasionally stop an application instance and start a new one.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-156.html">PAGE 156</a></h6> <p>Chapter 9 Deployment and Performance Issues users to be able to end their sessions ﬁrst, you might write the following code: // WebScript Application.wos id startDate; - init { [super init]; [self setMinimumActiveSessionCount:1]; return self; } - sleep { if (!startDate) // get the start date from statisticsStore { [[[self statisticsStore] statistics] objectForKey:@"StartedAt"]; } // Compare start date to current date. If the difference is // greater than 24 hours, refuse any new sessions.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-157.html">PAGE 157</a></h6> <p>Performance Tips component’s template (the result of parsing the .html and .wod ﬁles) and information about resources the component uses. If you cache component deﬁnitions, the .html and .wod ﬁles are parsed only once per application rather than once per new instance of that component. To cache component deﬁnitions, use WOApplication’s setCachingEnabled: method. public Application() { super(); this.setCachingEnabled(true); ... } By default, this type of caching is disabled as a convenience for debugging.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-158.html">PAGE 158</a></h6> <p>Chapter 9 Deployment and Performance Issues Limit State Storage As the amount of memory required by an application becomes large, its performance decreases. You can solve this problem by limiting the amount of state stored in memory or by storing state using some other means, as described in the chapter “Managing State” (page 109). You can also set up the application so that it shuts down if certain conditions occur, as described in the section “Automatically Terminating an Application” (page 155).</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-159.html">PAGE 159</a></h6> <p>Installing Applications Consider implementing a batching display mechanism to display the information in the table. For example, if the array contains hundreds of entries, you might choose to only display the ﬁrst 10 and provide a button that allows the user to see the next 10 entries. If the repetition is populated by a WODisplayGroup, you can use WODisplayGroup’s setNumberOfObjectsPerBatch: method to set up this batching, and it then controls the display for you.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-160.html">PAGE 160</a></h6> <p>Chapter 9 Deployment and Performance Issues NeXT_ROOT/NextLibrary/WOApps. Thus, you can install the entire directory under <DocRoot>/WebObjects, but doing so presents a security problem if you have scripted components. Any client can access any ﬁle under the document root, which means that if you install scripted components under the document root, you are exposing source code to outside users.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-161.html">PAGE 161</a></h6> <p>WEBSCRIPT</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-162.html">PAGE 162</a></h6> <p></p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-163.html">PAGE 163</a></h6> <p>Chapter 10 The WebScript Language</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-164.html">PAGE 164</a></h6> <p></p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-165.html">PAGE 165</a></h6> <p>To speed the development cycle, you may want to write your application in a scripting language. The WebObjects scripting language is called WebScript. You can write all or part of your WebObjects application in WebScript. This chapter tells you everything you need to know to use the WebScript language: its syntax and language constructs. WebScript is very similar to Objective-C.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-166.html">PAGE 166</a></h6> <p>Chapter 10 The WebScript Language id number, aName; - awake { if (!number) { number = [[self application] visitorNum]; number++; [[self application] setVisitorNum:number]; } return self; } - recordMe { if ([aName length]) { [[self application] setLastVisitor:aName]; [self setAName:@""]; // clear the text field } } Instance variables are declared at the top of the script ﬁle. In the example above, number and aName are instance variables. An object’s behavior is deﬁned by its methods.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-167.html">PAGE 167</a></h6> <p>WebScript Language Elements In these declarations, id is a data type. The id type is a reference to any object—in reality, a pointer to the object’s data (its instance variables). Like a C function or an array, an object is identiﬁed by its address; thus, all variables declared in WebScript are pointers to objects. In the examples above, myVar1 and myVar2 could be any object: a string, an array, or a custom object from your application. Note: Unlike C, no pointer manipulation is allowed in WebScript.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-168.html">PAGE 168</a></h6> <p>Chapter 10 The WebScript Language The scope of an instance variable is object-wide. That means that any method in the object can access any instance variable. You can’t directly access an instance variable outside of the object that owns it; you must use an accessor method instead. See “Accessor Methods” (page 171). The lifetime of an instance variable is the same as the lifetime of the object.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-169.html">PAGE 169</a></h6> <p>WebScript Language Elements // assign another variable to a variable myVar = anotherVar; // assign a string constant to a variable myString = @"This is my string."; Note: The // syntax denotes a comment. You can assign constant values to objects of four of the most commonly used classes in WebScript: NSNumber, NSString, NSArray, and NSDictionary. These classes are deﬁned in the Foundation framework.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-170.html">PAGE 170</a></h6> <p>Chapter 10 The WebScript Language For more information on NSNumber, NSString, NSDictionary, and NSArray, see the chapter “WebScript Programmer’s Quick Reference to Foundation Classes” (page 187). Methods To deﬁne a new method, simply put its implementation in the script ﬁle. You don’t need to declare it ahead of time.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-171.html">PAGE 171</a></h6> <p>WebScript Language Elements • A return type of void is not allowed: // This won’t work either. - (void) aMethod:(NSString *)anArg { ... } Both example methods return a value, stored in result. If a method doesn’t return a meaningful value, you don’t have to include a return statement (and, as stated above, even if a method returns no value you shouldn’t declare it as returning void). Invoking Methods When you want an object to perform one of its methods, you send the object a message.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-172.html">PAGE 172</a></h6> <p>Chapter 10 The WebScript Language automatically deﬁnes two accessor methods: one to retrieve the instance variable’s value, and one to change the value. For example, the Application.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-173.html">PAGE 173</a></h6> <p>WebScript Language Elements aString = [NSString stringWithString:@"Fred"]; Note that a class is represented in a script by its corresponding class name— in this example, NSString. In WebScript, the classes you use include both class methods and instance methods. Most class methods create a new instance of that class, whereas instance methods provide behavior for instances of the class. In the following example, a class method, stringWithFormat:, is used to create an instance of a class, NSString.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-174.html">PAGE 174</a></h6> <p>Chapter 10 The WebScript Language // Create a mutable string string = [NSMutableString stringWithFormat:@"The string is %@", aString]; // Create an immutable string string = [NSString stringWithFormat:@"The string is %@", aString]; // Create a mutable array array = [NSMutableArray array]; anotherArray = [NSMutableArray arrayWithObjects:@"Marsha", @"Greg", @"Cindy", nil]; // Create an immutable array array = [NSArray arrayWithObjects:@"Bobby", @"Jan", @"Peter", nil]; // Create a mutable dictionary dictiona</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-175.html">PAGE 175</a></h6> <p>WebScript Language Elements Explicitly specifying a class in a variable or method declaration is called static typing. Because variables and return values are always objects, the only supported data types are classes. You can specify any class that your application recognizes when you statically type a variable or a method.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-176.html">PAGE 176</a></h6> <p>Chapter 10 The WebScript Language Control-Flow Statements WebScript supports the following control-ﬂow statements: if else for while break continue return Arithmetic Operators WebScript supports the arithmetic operators +, - , /, *, and %. The rules of precedence in WebScript are the same as those for the C language. You can use these operators in compound statements such as: b = (1.0 + 3.23546) + (((1.0 * 2.3445) + 0.45 + 0.65) - 3.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-177.html">PAGE 177</a></h6> <p>WebScript Language Elements In WebScript, relational operators are only reliable on NSNumbers. If you try to use them on any other class of object, you may not receive the results you expect. For example, the following statement compares the addresses stored in the two string variables. If both point to the same address, the strings are equal. If they point to different addresses, even if the strings have identical contents, the statement will be false.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-178.html">PAGE 178</a></h6> <p>Chapter 10 The WebScript Language The postincrement and postdecrement operators are not supported. They behave like the preincrement and predecrement operators. For example: // WATCH OUT!! Probably not what you want. i = 0; while (i++ < 1) { //this loop never gets executed because i++ is a preincrement.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-179.html">PAGE 179</a></h6> <p>WebScript Language Elements [self application] WOComponent also deﬁnes a session method, so you can do this to retrieve the current session: [self session] Sometimes, you actually do want to invoke the superclass’s method rather than the current object’s method. For example, when you initialize an object, you should always give the superclass a chance to perform its initialization method before the current subclass.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-180.html">PAGE 180</a></h6> <p>Chapter 10 The WebScript Language Modern: function submit() { // <body> } • Method Deﬁnition With Arguments Classic: - takeValuesFromRequest:(WORequest *)request inContext:(WOContext *)context { // <body> } Modern: //Note: no static typing allowed. function takeValues(fromRequest:= request inContext:= context){ // <body> } • Method Invocation — No Argument Classic: [self doIt]; Modern: self.doIt(); • Method Invocation — One Argument Classic: [guests addObject:newGuest]; Modern: guests.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-181.html">PAGE 181</a></h6> <p>Advanced WebScript Note that in this last example the left parenthesis should occur at a break between words when the modern message maps to an existing ObjectiveC method (which, of course, follows classic WebScript syntax). When WebScript transforms modern to classic syntax internally, it capitalizes this character before concatenating the keywords of the selector. Thus, any of the following are correct: super.takeValuesFrom(request := request, inContext := context); super.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-182.html">PAGE 182</a></h6> <p>Chapter 10 The WebScript Language @interface Surfshop:NSObject { id name; NSArray *employees; } @end @implementation Surfshop - (Surfshop *)initWithName:aName employees:theEmployees { name = [aName copy]; employees = [theEmployees retain]; return self; } @end Do not use separate ﬁles for the @interface and @implementation blocks. They must both be in the same ﬁle. To use the class, you locate it in the application, load it, and then allocate and initialize instances using the class object.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-183.html">PAGE 183</a></h6> <p>WebScript for Objective-C Developers The following example is a simple category of WORequest that gets the sender’s Internet e-mail address from the request headers (“From” key) and returns it (or “None”). @implementation WORequest(RequestUtilities) - emailAddressOfSender { NSString *address = [self headerForKey:@"From"]; if (!address) address = @"None"; return address; } @end Elsewhere in your WebScript code, you invoke this method on WORequest objects just as you do with any other method of that class.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-184.html">PAGE 184</a></h6> <p>Chapter 10 The WebScript Language Objective-C WebScript Methods not declared to return void must include a return Methods aren’t required to include a return statement statement Has preprocessor support Has no preprocessor support—that is, doesn’t support the #deﬁne, #import, or #include statements Uses reference counting to determine when to release instance variables Automatically retains all instance variables for the life of the object that owns them.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-185.html">PAGE 185</a></h6> <p>WebScript for Objective-C Developers • You can only use the “at sign” character (@) as a conversion character with methods that take a format string as an argument: // This is fine. [self logWithFormat:@"The value is %@", myVar]; // NO!! This won’t work. It prints the address of var1. [self logWithFormat:@"The values are %d and %s", var1, var2]; • You need to substitute integer values for enumerated types.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-186.html">PAGE 186</a></h6> <p>Chapter 10 The WebScript Language To access a component’s methods, you must store the component in the session and then access it through the session. For example, suppose you wanted to rewrite the SelectedCars component of the DodgeDemo so that its database fetch code was in a compiled object and that object directly set the value of the message variable in the SelectedCars component. You’d add the following statement to the init method SelectedCars.wos: /* Store the component in the session. */ [self.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-187.html">PAGE 187</a></h6> <p>Chapter 11 WebScript Programmer’s Quick Reference to Foundation Classes</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-188.html">PAGE 188</a></h6> <p></p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-189.html">PAGE 189</a></h6> <p>As you learned in the previous chapter, when you write an application in WebScript, all values are objects, even simple values such as numbers or strings. The objects that represent strings, numbers, arrays, dictionaries, and other basic constructs are deﬁned by classes in the Foundation framework. You use classes from the Foundation framework in virtually all WebScript applications. This chapter gives you an overview of the Foundation framework classes most commonly used in WebScript.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-190.html">PAGE 190</a></h6> <p>Chapter 11 WebScript Programmer’s Quick Reference to Foundation Classes Determining Equality You can determine if two objects are equal using the isEqual: method. This method returns YES if the receiver of the message and the speciﬁed object are equal, and NO otherwise. The deﬁnition of equality depends on the object’s type. For example, array objects deﬁne two arrays as equal if they contain the same contents. For more information, see the isEqual: method descriptions later in this chapter.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-191.html">PAGE 191</a></h6> <p>Working With Strings Note: The conﬁguration of your HTTP server determines the user who owns autostarted applications. Reading From Files The string, array, and dictionary classes provide methods of the form classNameWithContentsOfFile:. These methods create a new object and initialize it with the contents of a speciﬁed ﬁle, which can be speciﬁed with a full or relative pathname. Working With Strings NSString and NSMutableString objects represent static and dynamic character strings, respectively.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-192.html">PAGE 192</a></h6> <p>Chapter 11 WebScript Programmer’s Quick Reference to Foundation Classes Commonly Used String Methods The following sections list the most commonly used NSString and NSMutableString methods, grouped according to function. Creating Strings The methods for creating strings are class methods, denoted by the plus sign (+). You use class methods to send messages to a class—in this case, NSString and NSMutableString. For more information on class methods, see “Sending a Message to a Class” (page 172).</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-193.html">PAGE 193</a></h6> <p>Commonly Used String Methods + stringWithContentsOfFile: Returns a string created by reading characters from a speciﬁed ﬁle. For example, the following statement creates an NSString containing the contents of the ﬁle speciﬁed in path: id fileContents = [NSString stringWithContentsOfFile:path]; See also writeToFile:atomically: (page 195) .</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-194.html">PAGE 194</a></h6> <p>Chapter 11 WebScript Programmer’s Quick Reference to Foundation Classes – substringFromIndex: Returns a string containing the characters of the receiver from the character at the speciﬁed index to the end. Comparing Strings – compare: Returns –1 if the receiver precedes a speciﬁed string in lexical ordering, 0 if it is equal, and 1 if it follows. For example, the following statements result in an NSString that has the contents “‘hello’ precedes ‘Hello’ lexicographically.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-195.html">PAGE 195</a></h6> <p>Commonly Used String Methods Modifying Strings Warning: The following methods are not supported by NSString. They are available only to NSMutableString objects. – appendFormat: Appends a constructed string to the receiver. Creates the new string by using the stringWithFormat: method with the arguments listed.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-196.html">PAGE 196</a></h6> <p>Chapter 11 WebScript Programmer’s Quick Reference to Foundation Classes Working With Arrays NSArray and NSMutableArray objects manage immutable and mutable collections of objects, respectively. Each has the following attributes: • • A count of the number of objects in the array The objects contained in the array The difference between NSArray and NSMutableArray is that you can’t add to or remove from an NSArray’s initial collection of objects.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-197.html">PAGE 197</a></h6> <p>Commonly Used Array Methods Creating Arrays The methods in this section are class methods, as denoted by the plus sign (+). You use class methods to send messages to a class—in this case, NSArray or NSMutableArray. For more information on class methods, see “Sending a Message to a Class” (page 172). + array Returns an empty array. Usually used to create NSMutableArrays. NSArrays created with this method are permanently empty.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-198.html">PAGE 198</a></h6> <p>Chapter 11 WebScript Programmer’s Quick Reference to Foundation Classes – isEqual: Returns YES if the speciﬁed object is an array and has contents equivalent to the receiver; NO, otherwise. Two arrays have equal contents if they each hold the same number of objects and objects at a given index in each array satisfy the isEqual: test. – objectAtIndex: Returns the object located at a speciﬁed index. Arrays have a zerobased index.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-199.html">PAGE 199</a></h6> <p>Commonly Used Array Methods – insertObject:atIndex: Inserts an object at a speciﬁed index. If the speciﬁed index is already occupied, the objects at that index and beyond are shifted down one slot to make room. The speciﬁed index can’t be greater than the receiver’s count, and the speciﬁed object cannot be nil. Array objects have a zero-based index. The ﬁrst object in an array is at index 0, the second is at index 1, and so on. You can insert only new objects in ascending order—with no gaps.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-200.html">PAGE 200</a></h6> <p>Chapter 11 WebScript Programmer’s Quick Reference to Foundation Classes Storing Arrays – writeToFile:atomically: Writes the array’s string representation to a speciﬁed ﬁle using the description method. Returns YES on success and NO on failure. If YES is speciﬁed for atomically:, this method attempts to write the ﬁle safely so that an existing ﬁle with the speciﬁed path is not overwritten, and it does not create a new ﬁle at the speciﬁed path unless the write is successful.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-201.html">PAGE 201</a></h6> <p>Commonly Used Dictionary Methods the key’s value. Within a dictionary, the keys are unique. That is, no two keys in a single dictionary are equivalent. The difference between NSDictionary and NSMutableDictionary is that you can’t add, modify, or remove entries from an NSDictionary’s initial collection of entries. Insertion and deletion methods provided for NSMutableDictionaries are not available for NSDictionaries.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-202.html">PAGE 202</a></h6> <p>Chapter 11 WebScript Programmer’s Quick Reference to Foundation Classes Creating Dictionaries The methods in this section are class methods, as denoted by the plus sign (+). You use class methods to send messages to a class—in this case, NSDictionary and NSMutableDictionary. For more information on class methods, see “Sending a Message to a Class” (page 172). + dictionary Returns an empty dictionary. Usually used to create NSMutableDictionaries.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-203.html">PAGE 203</a></h6> <p>Commonly Used Dictionary Methods Querying Dictionaries – allKeys Returns an array containing the dictionary’s keys or an empty array if the dictionary has no entries. This method is useful for accessing all the entries in a dictionary.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-204.html">PAGE 204</a></h6> <p>Chapter 11 WebScript Programmer’s Quick Reference to Foundation Classes – isEqual: Returns YES if the speciﬁed object is a dictionary and has contents equivalent to the receiver; NO, otherwise. Two dictionaries have equivalent contents if they each hold the same number of entries and, for a given key, the corresponding value objects in each dictionary satisfy the isEqual: test. – objectForKey: Returns the object that corresponds to a speciﬁed key.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-205.html">PAGE 205</a></h6> <p>Commonly Used Dictionary Methods – removeObjectForKey: Removes the entry for a speciﬁed key. – removeObjectsForKeys: Removes the entries for each key in a speciﬁed array. – setDictionary: Removes all the entries in the receiver, then adds the entries from a speciﬁed dictionary. Representing Dictionaries as Strings – description Returns a string that represents the contents of the receiver.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-206.html">PAGE 206</a></h6> <p>Chapter 11 WebScript Programmer’s Quick Reference to Foundation Classes Working With Dates and Times NSCalendarDate objects represent dates and times. These objects are especially suited for representing and manipulating dates according to Western calendrical systems. NSCalendarDate performs date computations based on Western calendrical systems, primarily the Gregorian. The methods provided by NSCalendarDate are described in more detail in “Commonly Used Date Methods” (page 207).</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-207.html">PAGE 207</a></h6> <p>Commonly Used Date Methods Conversion Speciﬁer Argument Type %x date using date representation for the locale %X time using time representation for the locale %Y, %y year with century (such as 1990) and year without century (00-99), respectively %Z, %z time zone abbreviation (such as PDT) and time zone offset in hours and minutes from GMT (HHMM), respectively Commonly Used Date Methods The following sections list some of the most commonly used methods of NSCalendarDate, grouped according to funct</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-208.html">PAGE 208</a></h6> <p>Chapter 11 WebScript Programmer’s Quick Reference to Foundation Classes Representing Dates as Strings – description Returns a string representation of the NSCalendarDate formatted according to the NSCalendarDate’s default calendar format. – descriptionWithCalendarFormat: Returns a string representation of the receiver formatted according to the provided format string. – calendarFormat Returns a string that indicates the receiver’s default calendar format.</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-209.html">PAGE 209</a></h6> <p>Commonly Used Date Methods – minuteOfHour Returns the NSCalendarDate’s minutes value (0–59). – secondOfMinute Returns the NSCalendarDate’s seconds value (0–59).</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-210.html">PAGE 210</a></h6> <p></p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-211.html">PAGE 211</a></h6> <p>Index</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-212.html">PAGE 212</a></h6> <p></p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-213.html">PAGE 213</a></h6> <p>Index %@ 59 .api file 20 .html file 20, 21 .wo directory, See wo directory .woa directory, See woa directory .wod file, See wod file .</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-214.html">PAGE 214</a></h6> <p>Index synchronization 85, 102–104 client-side 85–86 template 82–83 URL, specifying 53 variables 118–120 in reusable components 97 componentsJoinedByString: method 200 componentsSeparatedByString: method 193 conceptual overview of WebObjects 65–87 constants, WebScript 169–170 constructors 46–50 context ID 68, 77 context, accessing 51 cookies 126–128 count method 197, 203 createSession method 75 creating new component 76–77 creating new session 74–75 creating objects 173–174 current component 84 custom objec</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-215.html">PAGE 215</a></h6> <p>Index initObject:withCoder: method 132 initWithCoder: method 132–133 example 133 input postprocessing 51 insertObject:atIndex: method 199 install 159–160 instance variables, definition 165 instance, definition 165 integers in WebScript 169 @interface 181 intValue method 194 invokeActionForRequest:inContext: method 52–53, 79–80 declaration 70 example 52–53 ISAPI adaptor 26 isEqual: method 190, 194, 198, 204 isolating errors 60 isTerminating method 135 J Java support AppletGroupController class 143 applets,</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-216.html">PAGE 216</a></h6> <p>Index R recording statistics 151–153 refuseNewSessions: method 155 regenerating request page 45 registerForEvents method 73 relational operators 176 release method (Objective-C only) 46 example 137 removeAllObjects method 199, 204 removeObject: method 199 removeObjectAtIndex: method 199 removeObjectForKey: method 205 removeObjectIdenticalTo: method 199 removeObjectsForKeys: method 205 request component 44 request page 44, 73, 76–78 regenerating 45 request URL 75 request, accessing 51 request-handling meth</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-217.html">PAGE 217</a></h6> <p>Index stringWithContentsOfFile: method 190–191, 193 stringWithFormat: method 192 stringWithString: method 192 subclass, definition 166 substringFromIndex: method 194 substringToIndex: method 193 super 178–179 superclass, definition 166 synchronization of components 85, 102–104 client-side 85–86 syntax, WebScript 166–181 modern 179–181 T takeValuesFromRequest:inContext: method 51, 78–79 declaration 70 examples 51 teminate method 135 template 82–83 terminateAfterTimeInterval: method 155 terminating applicat</p> </li> <li> <h6><a class="text-decoration-none text-link fw-bold" href="/manual/apple/webobjects-3-5/owner-s-manual-english/page-218.html">PAGE 218</a></h6> <p>Index terminateAfterTimeInterval: method 155 trace methods 59–60 WOAssociation 71, 84–85 WOComponent 23–24, 69–71, 82–87, 105 See also components appendToResponse:inContext: method 81 awake method 77 descriptionForResponse:inContext: 81 init method 49–50, 77 invokeActionForRequest:inContext: method 79 performParentAction: method 86, 100 sleep method 81 state 113–120, 135–140 takeValuesFromRequest:inContext: method 78 WOContext 50, 69, 83 current component 84 request-response loop 74 .</p> </li> </ul> </nav> </div> </section> </section> </main> <footer class="page-footer"> <div class="container flex-column py-3 py-sm-4"> <div class="row mb-1 mb-sm-2 mb-md-5"> <a href="/" class="brand offset-sm-0 col-sm-4 col-md-3 col-lg-2 offset-2 col-8 text-center text-md-start"><img class="logo-small" src="/assets/img/brand-large.png" alt="Manualshelf"/></a> </div> <div class="row"> <dl class="text-center text-sm-start col-sm-3"> <dt class="fw-bold">Who We Are</dt> <dd><a class="text-decoration-none" href="/about">About Us</a></dd> <dd><a class="text-decoration-none" href="/company">Company</a></dd> <dd><a class="text-decoration-none" href="/careers">Careers</a></dd> <dd><a class="text-decoration-none" href="/terms">Terms & Privacy</a></dd> </dl> <dl class="text-center text-sm-start col-sm-3"> <dt class="fw-bold">Resources</dt> <dd><a class="text-decoration-none" href="/brands">List of Manufacturers</a></dd> <dd><a class="text-decoration-none" href="/">Support</a></dd> <dd><a class="text-decoration-none" href="/press">For the Press</a></dd> <dd><a class="text-decoration-none" href="/press#assets">Media assets</a></dd> <dd><a class="text-decoration-none" href="/faq">FAQ</a></dd> </dl> <dl class="text-center text-sm-start col-sm-3"> <dt class="fw-bold">Get in touch</dt> <dd><a class="text-decoration-none" href="#">Blog</a></dd> <dd><a class="text-decoration-none" href="#">Email</a></dd> <dd><a class="text-decoration-none" href="/dmca">DMCA</a></dd> </dl> </div> <div class="row"> <div class="text-center text-sm-start col-sm-4 pe-sm-0"> <a href="https://www.facebook.com/pages/ManualShelf/1488826334681423" class="fs-5 text-center d-inline-block social rounded-2 align-middle text-decoration-none me-2"><i class="fab fa-facebook-f"></i></a> <a href="https://www.twitter.com/ManualShelf" class="fs-5 text-center d-inline-block social rounded-2 align-middle text-decoration-none me-2"><i class="fab fa-twitter"></i></a> <a href="https://plus.google.com/+ManualShelf" class="fs-5 text-center d-inline-block social rounded-2 align-middle text-decoration-none me-2"><i class="fab fa-google-plus-g"></i></a> <a href="http://www.pinterest.com/ManualShelf" class="fs-5 text-center d-inline-block social rounded-2 align-middle text-decoration-none"><i class="fab fa-pinterest-p"></i></a> </div> <div class="col col-sm-8 d-flex flex-column align-items-center flex-sm-row flex-wrap flex-sm-nowrap justify-content-center justify-content-sm-end"> <div class="copy w-auto d-flex align-items-center justify-content-center justify-content-sm-end mt-2 mt-sm-0 me-2">ManualShelf © 2013-2025</div> <select class="form-select form-select-sm w-auto mt-2 mt-sm-0"> <option value="usa">USA</option> </select> <div> </div> </div>  <div id='pixel'> <script> googletag.cmd.push(function() { googletag.display('pixel'); }); </script> </div> </footer>  <script src="/assets/js/jquery-3.3.1.min.js"></script> <script src="/assets/js/bootstrap.bundle.min.js"></script> <script src="/assets/js/jquery.autocomplete.min.js"></script>  <script type="text/javascript"> $.extend({ redirectPost: function(location, args) { var form = ''; $.each(args, function(key, value) { form += '<input type="hidden" name="' + key + '" value="' + value + '">'; }); form = '<form id="s1" action="' + location + '" method="POST">' + form + '</form>'; $(document.body).append(form); $("#s1").submit(); } }); $(document).ready(function(){ $("#query").autocomplete({ minChars: 3, groupBy: 'type', paramName: 'q', dataType: 'json', serviceUrl: '/autocomplete', noCache: true, showNoSuggestionNotice: true, noSuggestionNotice: 'Zarro results found', onSelect: function (suggestion) { $.redirectPost(suggestion.data.url, {highlight: encodeURIComponent(JSON.stringify(suggestion.data.hls))}); } }); var toc = $('.toc-selector'); if (toc.length) { var slideParams = { duration: 800, easing: 'linear' }; toc.click(function() { $(this).toggleClass('open'); var section = $('.toc-content'); var isCollapsed = section.attr('data-collapsed') === 'true'; if (isCollapsed) { section.slideDown(slideParams) section.attr('data-collapsed', 'false') } else { section.slideUp(slideParams); section.attr('data-collapsed', 'true') } }); } }); var lastSmall = $(window).width() < 576; $(window).resize(function() { var newSmall = $(window).width() < 576; if (lastSmall != newSmall) { lastSmall = newSmall; window.location.href = window.location.href; } }); </script> </body> </html>