Terimber Corporation

00001 /*
00002  * The Software License
00003  * =================================================================================
00004  * Copyright (c) 2003-.The Terimber Corporation. All rights reserved.
00005  * =================================================================================
00006  * Redistributions of source code must retain the above copyright notice, 
00007  * this list of conditions and the following disclaimer.
00008  * Redistributions in binary form must reproduce the above copyright notice, 
00009  * this list of conditions and the following disclaimer in the documentation 
00010  * and/or other materials provided with the distribution.
00011  * The end-user documentation included with the redistribution, if any, 
00012  * must include the following acknowledgment:
00013  * "This product includes software developed by the Terimber Corporation."
00014  * =================================================================================
00015  * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED WARRANTIES, 
00016  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY 
00017  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  
00018  * IN NO EVENT SHALL THE TERIMBER CORPORATION OR ITS CONTRIBUTORS BE LIABLE FOR 
00019  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
00020  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
00021  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 
00022  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
00023  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
00024  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00025  * ================================================================================
00026 */
00027 
00028 #include "smart/varmap.hpp"
00029 #include "smart/varvalue.hpp"
00030 #include "base/string.hpp"
00031 #include "base/memory.hpp"
00032 
00033 
00034 BEGIN_TERIMBER_NAMESPACE
00035 #pragma pack(4)
00036 
00037 // constuctor with memory reallocation
00038 // ordinary value constractor
00039 // @factory can be null for temporary objects
00040 main_map_key::main_map_key(vt_types type, const var_value& val, variant_factory* factory)
00041 {
00042         if (factory)
00043         {
00044                 factory->clone(type, _var_res._val, val);
00045         }
00046         else
00047         {
00048                 _var_res._val = val;
00049         }
00050 }
00051 
00052 // constuctor with memory reallocation
00053 // for partial match only
00054 // @factory can be null for temporary objects
00055 main_map_key::main_map_key(const char* val, variant_factory* factory)
00056 {
00057         _var_res._key._offsets = 0;
00058 
00059         if (factory)
00060         {
00061                 _var_res._key._res = 0;
00062 
00063                 var_value val_in, val_out;
00064                 val_in._not_null = val != 0;
00065                 val_in._value.strVal = val;
00066 
00067                 factory->clone(vt_string, val_out, val_in);
00068 
00069                 _var_res._key._res = val_out._value.strVal;
00070                         
00071                 ub1_t offlen = 0;
00072                 ub4_t offsets[0xff];
00073 
00074                 // tokenizes string
00075                 const char* begin = val;
00076                 bool space_found = false;
00077                 
00078                 while (val && *val == ' ')
00079                         ++val;
00080 
00081                 while (val && *val && offlen < 0xff)
00082                 {
00083                         // spaces allowed whitespace, tab, new line vertical tab
00084                         // #x20 | #x9 | #xD | #xA
00085                         switch (*val)
00086                         {
00087                                 case 0x20:
00088                                 case 0x09:
00089                                 case 0x0D:
00090                                 case 0x0A:
00091                                         if (!space_found)
00092                                                 space_found = true;
00093                                         break;
00094                                 default:
00095                                         if (space_found)
00096                                         {
00097                                                 offsets[offlen] = (ub4_t)(val - begin);
00098                                                 space_found = false;
00099                                                 ++offlen;
00100                                         }
00101                         } // switch
00102 
00103                         ++val;
00104                 }
00105 
00106                 if (offlen)
00107                 {
00108                         // allocates offsets
00109                         factory->create(vt_numeric, val_out, sizeof(ub4_t) * (offlen + 1));
00110                         ub4_t* p = (ub4_t*)val_out._value.bufVal;
00111                         
00112                         memcpy(p + 1, offsets, sizeof(ub4_t) * offlen);
00113                         *p = offlen;
00114                         _var_res._key._offsets = p;
00115                 }
00116         }
00117         else
00118         {
00119                 _var_res._key._res = val;
00120         }
00121 }
00122 
00123 main_map_key::main_map_key(size_t fuzzyident, const char* val, variant_factory* factory)
00124 {
00125         _var_res._ngram._fuzzy_key = fuzzyident;
00126 
00127         if (factory)
00128         {
00129                 _var_res._ngram._res = 0;
00130 
00131                 var_value val_in, val_out;
00132                 val_in._not_null = val != 0;
00133                 val_in._value.strVal = val;
00134 
00135                 factory->clone(vt_string, val_out, val_in);
00136 
00137                 _var_res._ngram._res = val_out._value.strVal;
00138         }
00139         else
00140         {
00141                 _var_res._key._res = val;
00142         }
00143 }
00144 
00145 main_map_key::main_map_key(const main_map_key& x)
00146 {
00147         memcpy(&_var_res, &x._var_res, sizeof(var_key));
00148 }
00149 
00150 #pragma pack()
00151 END_TERIMBER_NAMESPACE
varmap.cpp
