NAME

       LucyX::Index::ByteBufDocWriter - Write a Doc as a fixed-width byte array.

SYNOPSIS

       Create an Architecture subclass which overrides register_doc_writer() and
       register_doc_reader():

           package MyArchitecture;
           use base qw( Lucy::Plan::Architecture );
           use LucyX::Index::ByteBufDocReader;
           use LucyX::Index::ByteBufDocWriter;

           sub register_doc_writer {
               my ( $self, $seg_writer ) = @_;
               my $doc_writer = LucyX::Index::ByteBufDocWriter->new(
                   width      => 16,
                   field      => 'value',
                   snapshot   => $seg_writer->get_snapshot,
                   segment    => $seg_writer->get_segment,
                   polyreader => $seg_writer->get_polyreader,
               );
               $seg_writer->register(
                   api       => "Lucy::Index::DocReader",
                   component => $doc_writer,
               );
               $seg_writer->add_writer($doc_writer);
           }

           sub register_doc_reader {
               my ( $self, $seg_reader ) = @_;
               my $doc_reader = LucyX::Index::ByteBufDocReader->new(
                   width    => 16,
                   field    => 'value',
                   schema   => $seg_reader->get_schema,
                   folder   => $seg_reader->get_folder,
                   segments => $seg_reader->get_segments,
                   seg_tick => $seg_reader->get_seg_tick,
                   snapshot => $seg_reader->get_snapshot,
               );
               $seg_reader->register(
                   api       => 'Lucy::Index::DocReader',
                   component => $doc_reader,
               );
           }

           package MySchema;
           use base qw( Lucy::Plan::Schema );

           sub architecture { MyArchitecture->new }

       Proceed as normal in your indexer app, making sure that every supplied document supplies a
       valid value for the field in question:

           $indexer->add_doc({
               title   => $title,
               content => $content,
               id      => $id,      # <---- Must meet spec.
           });

       Then, in your search app:

           my $searcher = Lucy::Search::IndexSearcher->new(
               index => '/path/to/index',
           );
           my $hits = $searcher->hits( query => $query );
           while ( my $id = $hits->next ) {
               my $real_doc = $external_document_source->fetch( $doc->{value} );
               ...
           }

DESCRIPTION

       This is a proof-of-concept class to demonstrate alternate implementations for fetching
       documents.  It is unsupported.