Home | History | Annotate | Line # | Download | only in src 
      1 /*
      2  * fontconfig/src/fcrange.c
      3  *
      4  * Copyright  2002 Keith Packard
      5  *
      6  * Permission to use, copy, modify, distribute, and sell this software and its
      7  * documentation for any purpose is hereby granted without fee, provided that
      8  * the above copyright notice appear in all copies and that both that
      9  * copyright notice and this permission notice appear in supporting
     10  * documentation, and that the name of the author(s) not be used in
     11  * advertising or publicity pertaining to distribution of the software without
     12  * specific, written prior permission.  The authors make no
     13  * representations about the suitability of this software for any purpose.  It
     14  * is provided "as is" without express or implied warranty.
     15  *
     16  * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
     17  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
     18  * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR
     19  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
     20  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
     21  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
     22  * PERFORMANCE OF THIS SOFTWARE.
     23  */
     24 
     25 #include "fcint.h"
     26 
     27 
     28 FcRange *
     29 FcRangeCreateDouble (double begin, double end)
     30 {
     31     FcRange *ret = malloc (sizeof (FcRange));
     32 
     33     if (ret)
     34     {
     35 	ret->begin = begin;
     36 	ret->end = end;
     37     }
     38 
     39     return ret;
     40 }
     41 
     42 FcRange *
     43 FcRangeCreateInteger (FcChar32 begin, FcChar32 end)
     44 {
     45     FcRange *ret = malloc (sizeof (FcRange));
     46 
     47     if (ret)
     48     {
     49 	ret->begin = begin;
     50 	ret->end = end;
     51     }
     52 
     53     return ret;
     54 }
     55 
     56 void
     57 FcRangeDestroy (FcRange *range)
     58 {
     59     if (range)
     60 	free (range);
     61 }
     62 
     63 FcRange *
     64 FcRangeCopy (const FcRange *range)
     65 {
     66     return FcRangeCreateDouble (range->begin, range->end);
     67 }
     68 
     69 FcBool
     70 FcRangeGetDouble(const FcRange *range, double *begin, double *end)
     71 {
     72     if (!range)
     73 	return FcFalse;
     74     if (begin)
     75 	*begin = range->begin;
     76     if (end)
     77 	*end = range->end;
     78 
     79     return FcTrue;
     80 }
     81 
     82 FcRange *
     83 FcRangePromote (double v, FcValuePromotionBuffer *vbuf)
     84 {
     85     typedef struct {
     86 	FcRange	r;
     87     } FcRangePromotionBuffer;
     88     FcRangePromotionBuffer *buf = (FcRangePromotionBuffer *) vbuf;
     89 
     90     FC_ASSERT_STATIC (sizeof (FcRangePromotionBuffer) <= sizeof (FcValuePromotionBuffer));
     91     buf->r.begin = v;
     92     buf->r.end = v;
     93 
     94     return &buf->r;
     95 }
     96 
     97 FcBool
     98 FcRangeIsInRange (const FcRange *a, const FcRange *b)
     99 {
    100     return a->begin >= b->begin && a->end <= b->end;
    101 }
    102 
    103 FcBool
    104 FcRangeCompare (FcOp op, const FcRange *a, const FcRange *b)
    105 {
    106     switch ((int) op) {
    107     case FcOpEqual:
    108 	return a->begin == b->begin && a->end == b->end;
    109     case FcOpContains:
    110     case FcOpListing:
    111 	return FcRangeIsInRange (a, b);
    112     case FcOpNotEqual:
    113 	return a->begin != b->begin || a->end != b->end;
    114     case FcOpNotContains:
    115 	return !FcRangeIsInRange (a, b);
    116     case FcOpLess:
    117 	return a->end < b->begin;
    118     case FcOpLessEqual:
    119 	return a->end <= b->begin;
    120     case FcOpMore:
    121 	return a->begin > b->end;
    122     case FcOpMoreEqual:
    123 	return a->begin >= b->end;
    124     default:
    125 	break;
    126     }
    127     return FcFalse;
    128 }
    129 
    130 FcChar32
    131 FcRangeHash (const FcRange *r)
    132 {
    133     int b = (int) (r->begin * 100);
    134     int e = (int) (r->end * 100);
    135 
    136     return b ^ (b << 1) ^ (e << 9);
    137 }
    138 
    139 FcBool
    140 FcRangeSerializeAlloc (FcSerialize *serialize, const FcRange *r)
    141 {
    142     if (!FcSerializeAlloc (serialize, r, sizeof (FcRange)))
    143 	return FcFalse;
    144     return FcTrue;
    145 }
    146 
    147 FcRange *
    148 FcRangeSerialize (FcSerialize *serialize, const FcRange *r)
    149 {
    150     FcRange *r_serialize = FcSerializePtr (serialize, r);
    151 
    152     if (!r_serialize)
    153 	return NULL;
    154     memcpy (r_serialize, r, sizeof (FcRange));
    155 
    156     return r_serialize;
    157 }
    158 
    159 #define __fcrange__
    160 #include "fcaliastail.h"
    161 #undef __fcrange__
    162