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__