---
name: "Lucy::Object::Obj"
section: "3pm"
platform: "linux"
package: "liblucy-perl"
version: "0.3.3-7+b1"
release: "Debian 9 (Stretch)"
platforms: ["linux"]
url: "https://new.carta.tech/Lucy::Object::Obj"
---

# Lucy::Object::Obj(3pm)

Base class for all Lucy objects.

## NAME

Lucy::Object::Obj - Base class for all Lucy objects.

## SYNOPSIS

```
    package MyObj;
    use base qw( Lucy::Object::Obj );

    # Inside-out member var.
    my %foo;

    sub new {
        my ( $class, %args ) = @_;
        my $foo = delete $args{foo};
        my $self = $class->SUPER::new(%args);
        $foo{$$self} = $foo;
        return $self;
    }

    sub get_foo {
        my $self = shift;
        return $foo{$$self};
    }

    sub DESTROY {
        my $self = shift;
        delete $foo{$$self};
        $self->SUPER::DESTROY;
    }
```

## DESCRIPTION

All objects in the Lucy:: hierarchy descend from Lucy::Object::Obj.  All classes are implemented as blessed scalar references, with the scalar storing a pointer to a C struct.

### Subclassing

The recommended way to subclass Lucy::Object::Obj and its descendants is to use the inside-out design pattern.  (See Class::InsideOut for an introduction to inside-out techniques.)

Since the blessed scalar stores a C pointer value which is unique per-object, `$$self` can be used as an inside-out ID.

```
    # Accessor for 'foo' member variable.
    sub get_foo {
        my $self = shift;
        return $foo{$$self};
    }
```

Caveats:

- •

  Inside-out aficionados will have noted that the "cached scalar id" stratagem recommended above isn't compatible with ithreads -- but Lucy doesn't support ithreads anyway, so it doesn't matter.

- •

  Overridden methods must not return undef unless the API specifies that returning undef is permissible.  (Failure to adhere to this rule currently results in a segfault rather than an exception.)

## CONSTRUCTOR

### *new()*

Abstract constructor -- must be invoked via a subclass.  Attempting to instantiate objects of class "Lucy::Object::Obj" directly causes an error.

Takes no arguments; if any are supplied, an error will be reported.

## DESTRUCTOR

### DESTROY

All Lucy classes implement a DESTROY method; if you override it in a subclass, you must call `"$self->SUPER::DESTROY"` to avoid leaking memory.

## ABSTRACT METHODS

### *to\_i64()*

Convert the object to a 64-bit integer.

### *to\_f64()*

Convert the object to a double precision floating point number.

### load(dump)

Create an object from the output of a call to *dump()*.  Implementations must not reference the caller.

- •

  **dump** - The output of *dump()*.

## METHODS

### *to\_string()*

Generic stringification: "ClassName@hex\_mem\_address".

### equals(other)

Indicate whether two objects are the same.  By default, compares the memory address.

- •

  **other** - Another Obj.

### *dump()*

Return a representation of the object using only scalars, hashes, and arrays.  Some implementations support JSON serialization via *dump()* and its companion method, *load()*; for others, *dump()* is only a debugging aid.  The default simply calls *to\_string()*.