FilesExpand file tree

master

/

CTObject.c

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

134 lines (119 loc) · 3.23 KB

master

/

CTObject.c

Copy path

Top

File metadata and controls

• Code
• Blame

134 lines (119 loc) · 3.23 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

//

// CTArray.c

// CTObject

//

// Created by Carlo Tortorella on 22/10/13.

// Copyright (c) 2013 Carlo Tortorella. All rights reserved.

//

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <assert.h>

#include "CTObject.h"

#include "CTDictionary.h"

#include "CTArray.h"

#include "CTNumber.h"

#include "CTString.h"

#include "CTNull.h"

inline void * CTObjectValueIfNonNilAndType(CTObjectRef object, CTOBJECT_TYPE type)

{

if (CTObjectNonNilAndType(object, type))

{

return CTObjectValue(object);

}

return NULL;

}

CTObjectRef CTObjectCreate(CTAllocatorRef restrict alloc, void * ptr, CTOBJECT_TYPE type)

{

CTObjectRef object = CTAllocatorAllocate(alloc, sizeof(CTObject));

object->alloc = alloc;

object->ptr = ptr;

object->type = type;

return object;

}

CTObjectRef CTObjectCopy(CTAllocatorRef restrict alloc, const CTObject * restrict object)

{

switch(object->type)

{

case CTOBJECT_TYPE_DICTIONARY:

return CTObjectWithDictionary(alloc, CTDictionaryCopy(alloc, object->ptr));

case CTOBJECT_TYPE_ARRAY:

return CTObjectWithArray(alloc, CTArrayCopy(alloc, object->ptr));

case CTOBJECT_TYPE_NUMBER:

return CTObjectWithNumber(alloc, CTNumberCopy(alloc, object->ptr));

case CTOBJECT_TYPE_LARGE_NUMBER:

return CTObjectWithLargeNumber(alloc, CTLargeNumberCopy(alloc, object->ptr));

case CTOBJECT_TYPE_STRING:

return CTObjectWithString(alloc, CTStringCopy(alloc, object->ptr));

default:

return CTObjectWithNull(alloc, CTNullCreate());

}

}

uint8_t CTObjectCompare(const CTObject * restrict object1, const CTObject * restrict object2)

{

if (object1 == object2)

{

return 1;

}

if (object1->type == object2->type)

{

switch(object1->type)

{

case CTOBJECT_TYPE_DICTIONARY:

return CTDictionaryCompare(object1->ptr, object2->ptr);

case CTOBJECT_TYPE_ARRAY:

return CTArrayCompare(object1->ptr, object2->ptr);

case CTOBJECT_TYPE_NUMBER:

return CTNumberCompare(object1->ptr, object2->ptr);

case CTOBJECT_TYPE_LARGE_NUMBER:

return CTLargeNumberCompare(object1->ptr, object2->ptr);

case CTOBJECT_TYPE_STRING:

return CTStringIsEqual(object1->ptr, object2->ptr);

case CTOBJECT_TYPE_NULL:

return 1;

case CTOBJECT_NOT_AN_OBJECT:

return 0;

}

}

return 0;

}

inline void * CTObjectValue(const CTObject * restrict object)

{

assert(object);

return object->ptr;

}

inline CTOBJECT_TYPE CTObjectType(const CTObject * restrict object)

{

assert(object);

return object->type;

}

inline uint64_t CTObjectSize(const CTObject * restrict object)

{

assert(object);

return object->size;

}

void CTObjectRelease(CTObjectRef object)

{

switch (object->type)

{

case CTOBJECT_TYPE_DICTIONARY:

CTDictionaryRelease(object->ptr);

break;

case CTOBJECT_TYPE_ARRAY:

CTArrayRelease(object->ptr);

break;

case CTOBJECT_TYPE_NUMBER:

CTNumberRelease(object->ptr);

break;

case CTOBJECT_TYPE_LARGE_NUMBER:

CTLargeNumberRelease(object->ptr);

break;

case CTOBJECT_TYPE_STRING:

CTStringRelease(object->ptr);

break;

case CTOBJECT_TYPE_NULL:

case CTOBJECT_NOT_AN_OBJECT:

break;

}

CTAllocatorDeallocate(object->alloc, object);

}