NAME
PUBLIC COSTANTS

Namespaces

PRIVATE CONSTANTS

Resource
Resource li
Resource Statement
Resource Literal
Resource Container
Resource Interface
Resource Service
Context

AUTHOR
COPYRIGHT
SUPPORT
CREDITS
SEE ALSO

NAME

RDF::Service::Constants

PUBLIC COSTANTS

Namespaces

  NS_RDF        => "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
  NS_RDFS       => "http://www.w3.org/2000-2001/01/rdf-schema#";
  NS_LS         => "http://uxn.nu/rdf/2000-2001/09/19/local-schema";
  NS_LD         => "http://uxn.nu/rdf/2000-2001/09/19/local-data";

PRIVATE CONSTANTS

Resource

These are the object variables for RDF::Service::Resource. Aka slots.

IDS

The Interface Domain Signature

See IDS page
URISTR

Scalar. Unique and always defined.
ID

Integer. Unique and always defined.
TYPE
```
  $self->[TYPE] = 
    {
      $type_id =>{ $model_id => 1, ... },
      ...
    };
```
$type_id is ID of the class node

$model_id is ID of the model containing the type statement

undef idicates uninitialized value
TYPE_ALL

value undef: Not all types initialized

value 1 : All types initialized. At least one not saved

value 2 : All types initialized and saved

Temporary or dynamix types doesn't need to be saved and thus is taken to be saved even if they aren't.
REV_TYPE

Same as TYPE, but in the opposit direction; The classes stores all resources that has it as a type.

Resource and Literal are special cases, and does not use this slot.
REV_TYPE_ALL

Same as TYPE_ALL, but for REV_TYPE

JUMPTABLE

A reference to a jumptable, shared by other nodes with the same JTK

  $self->[JUMPTABLE] = 
    {
      function =>[ [coderef, interface_node], ... ],
      ...
    };

NS

A reference to the resource whose URI is used as a namespace

This will be inferenced from the model

Not imlemented
NAME

A scalar string. The complement to NS

Not implemented
LABEL

A scalar string

Is defined if spcified by the MODEL for this node

Other labels can exist in other nodes, or as explicit statings

The implicit literal and the stating can be given URIs

Not implemented

PRIVATE

Private space in the node to be used by individual interfaces

  $self->[PRIVATE] =
    {
      interface_id => private_data_ref,
      ...
    };

MODEL

The model node for the node. See Nodes.
ALIASFOR

Is this resource alias for another resource?

(May have to have a separate model slot for this)

Not implemented
REV_PRED

Reference to all statements that use this node as a predicate
```
  $self->[REV_PRED] = [ $arc_node, ... ];
```
REV_PRED_ALL

Same as TYPE_ALL, but for REV_PRED

REV_SUBJ

Same as REV_PRED, but for subjects

  $self->[REV_SUBJ] =
    {
      prop_id => [ $arc_node, ... ],
      ...
    };

REV_SUBJ_ALL

Same as TYPE_ALL, but for REV_SUBJ

REV_OBJ

Same as REV_PRED, but for objects

  $self->[REV_OBJ] =
    {
      prop_id => [ $arc_node, ... ],
      ...
    };

REV_OBJ_ALL

Same as TYPE_ALL, but for REV_OBJ
JTK

Jump Table Key. Is combned from the IDS, URI-prefix ID and the list of types:
```
  IDS . '/' . URI_prefix_id . '/' . join('-', type_id_orderd_list)
```
Example: 5-8-12/9/1-4-11

5-8-12 is the IDS

9 is the URI-prefix, as given by RDF::Service::Resource/find_prefix_id

1-4-11 is the types of the node, given by RDF::Service::Context/type_orderd_list.

This slot is only used for debugging
MULTI

Is this an reified statement explicitely stored as several statements?

Not implemented
SOLID

value 1 indicate that the node with all implicit statements is saved (in a interface) or doesn't have to be saved.
RUNLEVEL

value 0 is used for the bootstrap process to allow partial initialization

value 1 is the normal runlevel

Resource li

Extra slots for RDF::Service::Resource, used by container entries

MEMBER

Not implemented

Resource Statement

Extra slots for RDF::Service::Resource, used by arcs

PRED

Points at the statement predicate
SUBJ

Points at the statement subject
OBJ

Points at the statement object

Resource Literal

Extra slots for RDF::Service::Resource, used by literals

VALUE

A scalar reference
LANG

Node reference

This holds the language stating from the same model

Language statings from other models is represented by arc nodes

Resource Container

Extra slots for RDF::Service::Resource, used by containers

REV_MODEL

Used by model nodes

Points back at all nodes that has this node as model
```
  $self->[REV_MODEL] =
    {
      node_id => node,
      ...
    };
```
CONTENT

See containers.

Not implemented
READONLY

Used by model nodes

Not implemented

Resource Interface

Extra slots for RDF::Service::Resource, used interfaces

PREFIX

Not implemented
MODULE_NAME

The name of the interface

Sort of not implemented

MODULE_REG

This is the source material for the construction of jumptables

Returned by the interfaces register() functions

  $self->[MODULE_REG] =
    {
      domain =>
        {
          type =>
            {
              function => [ coderef, ... ],
              ...
            },
          ...
        },
      ...
    };

Resource Service

Extra slots for RDF::Service::Resource, used by sessions

INTERFACES

A list of interfaces connected to the session
```
  $self->[INTERFACES] = [ interface_nose, ... ];
```

Context

Slots for RDF::Service::Context objects

CONTEXT

Points to node holding preferences

Not implemented
NODE

Points at the node
WMODEL

The working model for the context

New nodes created by context methods is placed in this model
MEMORY

Same as PRIVATE, but for contexts
HISTORY

This is a stack of dispatcher calls. Recursive calls adds to the stack. Used to catch cyclic recursive calls. It creates keys consisting of the function call, object and all args.

AUTHOR

Jonas Liljegren <jonas@paranormal.se>

  http://jonas.liljegren.org/myself/en/

COPYRIGHT

This module is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

SUPPORT

Comments and bug reports should go to rdf@uxn.nu.

CREDITS

Stefan Andersson <stefan@uxn.nu>