1 /*===========================================================================
2 *
3 *                            PUBLIC DOMAIN NOTICE
4 *               National Center for Biotechnology Information
5 *
6 *  This software/database is a "United States Government Work" under the
7 *  terms of the United States Copyright Act.  It was written as part of
8 *  the author's official duties as a United States Government employee and
9 *  thus cannot be copyrighted.  This software/database is freely available
10 *  to the public for use. The National Library of Medicine and the U.S.
11 *  Government have not placed any restriction on its use or reproduction.
12 *
13 *  Although all reasonable efforts have been taken to ensure the accuracy
14 *  and reliability of the software and data, the NLM and the U.S.
15 *  Government do not and cannot warrant the performance or results that
16 *  may be obtained by using this software or data. The NLM and the U.S.
17 *  Government disclaim all warranties, express or implied, including
18 *  warranties of performance, merchantability or fitness for any particular
19 *  purpose.
20 *
21 *  Please cite the author in any work or product based on this material.
22 *
23 * ===========================================================================
24 *
25 */
26 
27 #include <kfc/array.hpp>
28 #include <kfc/memmgr.hpp>
29 #include <kfc/caps.hpp>
30 #include <kfc/except.hpp>
31 #include <kfc/callstk.hpp>
32 
33 namespace vdb3
34 {
35 
36     /*------------------------------------------------------------------
37      * OpaqueArray
38      *  represents a container addressable by ordinal
39      */
40 
length() const41     count_t OpaqueArray :: length () const
42     {
43         return cnt;
44     }
45 
size() const46     bytes_t OpaqueArray :: size () const
47     {
48         return m . bytes;
49     }
50 
access(index_t offset,const bytes_t & elem_size)51     void * OpaqueArray :: access ( index_t offset, const bytes_t & elem_size )
52     {
53         if ( offset < 0 || ( U64 ) offset + elem_size > m . bytes )
54         {
55             FUNC_ENTRY ();
56 
57             bool okay = false;
58             if ( offset >= 0 )
59             {
60                 // try to resize the storage
61             }
62 
63             if ( ! okay )
64             {
65                 THROW ( xc_bounds_err, "memory read/write access of %lu bytes at index %ld"
66                         , ( U64 ) elem_size
67                         , offset / elem_size
68                     );
69             }
70         }
71 
72         return ( void* ) ( ( char* ) m . ptr + offset );
73     }
74 
access(index_t offset,const bytes_t & elem_size) const75     const void * OpaqueArray :: access ( index_t offset, const bytes_t & elem_size ) const
76     {
77         if ( offset < 0 || ( U64 ) offset + elem_size > m . bytes )
78         {
79             FUNC_ENTRY ();
80             THROW ( xc_bounds_err, "memory read access of %lu bytes at index %ld"
81                     , ( U64 ) elem_size
82                     , offset / elem_size
83                 );
84         }
85 
86         return ( const void* ) ( ( const char* ) m . ptr + offset );
87     }
88 
assign(const OpaqueArray & r)89     void OpaqueArray :: assign ( const OpaqueArray & r )
90     {
91         FUNC_ENTRY ();
92         m = r . m;
93         cnt = r . cnt;
94     }
95 
OpaqueArray()96     OpaqueArray :: OpaqueArray ()
97         : cnt ( 0 )
98     {
99     }
100 
OpaqueArray(const OpaqueArray & r)101     OpaqueArray :: OpaqueArray ( const OpaqueArray & r )
102         : m ( r . m )
103         , cnt ( r . cnt )
104     {
105     }
106 
OpaqueArray(const OpaqueArray & r,caps_t reduce)107     OpaqueArray :: OpaqueArray ( const OpaqueArray & r, caps_t reduce )
108         : m ( r . m )
109         , cnt ( r . cnt )
110     {
111     }
112 
~OpaqueArray()113     OpaqueArray :: ~ OpaqueArray ()
114     {
115         cnt = 0;
116     }
117 
OpaqueArray(Mem & _m,const bytes_t & elem_size)118     OpaqueArray :: OpaqueArray ( Mem & _m, const bytes_t & elem_size )
119         : m ( _m )
120         , cnt ( 0 )
121     {
122         FUNC_ENTRY ();
123         m . get_itf ( CAP_RDWR );
124 
125         if ( elem_size == ( U64 ) 0 )
126             CONST_THROW ( xc_div_zero_err, "divide by zero" );
127         if ( elem_size != ( U64 ) 1 )
128         {
129             if ( ( U64 ) m . bytes % elem_size != ( U64 ) 0 )
130                 CONST_THROW ( xc_elem_size_err, "memory block is not an integral multiple of array element size" );
131         }
132     }
133 
OpaqueArray(const Mem & _m,const bytes_t & elem_size)134     OpaqueArray :: OpaqueArray ( const Mem & _m, const bytes_t & elem_size )
135         : m ( _m )
136         , cnt ( 0 )
137     {
138         FUNC_ENTRY ();
139         m . get_itf ( CAP_READ );
140 
141         if ( elem_size == ( U64 ) 0 )
142             CONST_THROW ( xc_div_zero_err, "divide by zero" );
143         cnt = ( U64 ) _m . bytes;
144         if ( elem_size != ( U64 ) 1 )
145         {
146             if ( ( U64 ) m . bytes % elem_size != ( U64 ) 0 )
147                 CONST_THROW ( xc_elem_size_err, "memory block is not an integral multiple of array element size" );
148             cnt /= ( U64 ) elem_size;
149         }
150     }
151 
152 }
153